From 37a29e978609e48abdb0df870ad0676b067bd9b6 Mon Sep 17 00:00:00 2001
From: Jason Edward Stewart <jasons@apache.org>
Date: Mon, 11 Sep 2006 10:08:07 +0000
Subject: [PATCH] split out DOM and Transcoder into seperate modules
git-svn-id: https://svn.apache.org/repos/asf/xerces/c/trunk@442160 13f79535-47bb-0310-9956-ffa450edef68
---
swig/interfaces/Perl/Xerces-extra.pm | 204 +-
swig/interfaces/Perl/Xerces_DOM-extra.pm | 202 +
swig/interfaces/Perl/callback.i | 8 +
swig/interfaces/Perl/defines.i | 7 -
swig/interfaces/Perl/dom-callback.i | 65 +
.../{typemaps.i => Perl/dom-includes.i} | 19 +-
swig/interfaces/Perl/dom-shadow.i | 1 +
swig/interfaces/Perl/errors.i | 3 +
swig/interfaces/Perl/includes.i | 33 +
swig/interfaces/Perl/typemaps-xmlch.i | 31 +-
swig/interfaces/Perl/typemaps.i | 5 +-
swig/interfaces/Xerces.i | 70 +-
swig/interfaces/Xerces_DOM.i | 272 +
swig/interfaces/callback.i | 7 -
swig/interfaces/defines.i | 200 +-
swig/interfaces/dom-includes.i | 30 +
swig/interfaces/includes.i | 67 +
swig/interfaces/parsers.i | 4 +-
swig/interfaces/typemaps-general.i | 25 +-
swig/perl/DOM/DOM.pm | 2796 ++
swig/perl/DOM/Makefile.PL | 59 +
swig/perl/DOM/Xerces_DOM.cpp | 29032 ++++++++++++++
swig/perl/Handler/Makefile.PL | 21 -
swig/perl/Handler/PerlCallbackHandler.cpp | 61 +-
swig/perl/Handler/PerlCallbackHandler.hpp | 14 +-
.../Handler/PerlContentCallbackHandler.cpp | 47 +-
.../Handler/PerlDocumentCallbackHandler.cpp | 19 +-
...andler.i => PerlEntityResolverHandler.cpp} | 38 +-
.../perl/Handler/PerlErrorCallbackHandler.cpp | 21 +-
...er.i => PerlNodeFilterCallbackHandler.cpp} | 29 +-
swig/perl/Makefile.PL | 78 +-
swig/perl/TODO | 11 +-
swig/perl/Transcoder/Makefile.PL | 49 +
swig/perl/Transcoder/Transcoder.cpp | 154 +
swig/perl/Transcoder/Transcoder.hpp | 60 +
swig/perl/Transcoder/XMLExceptionHandler.cpp | 127 +
swig/perl/Transcoder/XMLExceptionHandler.hpp | 72 +
swig/perl/Xerces.cpp | 33315 ++--------------
swig/perl/Xerces.pm | 3077 +-
swig/perl/samples/DOM2hash.pl | 1 +
swig/perl/samples/DOMCount.pl | 2 +-
swig/perl/samples/DOMCreate.pl | 2 +-
swig/perl/samples/DOMPrint.pl | 2 +-
swig/perl/samples/validator-dom.pl | 2 +-
swig/perl/t/00dom_module.t | 33 +
swig/perl/t/00module.t | 33 +
swig/perl/t/01utf8.t | 15 +-
swig/perl/t/Attributes.t | 32 +-
swig/perl/t/DOMAttr.t | 32 +-
swig/perl/t/DOMBuilder.t | 2 +-
swig/perl/t/DOMConfig.t | 2 +-
swig/perl/t/DOMCount.t | 20 +-
swig/perl/t/DOMCreate.t | 15 +-
swig/perl/t/DOMDocument.t | 20 +-
swig/perl/t/DOMElement.t | 13 +-
swig/perl/t/DOMEntity.t | 13 +-
swig/perl/t/DOMException.t | 23 +-
swig/perl/t/DOMImplementation.t | 13 +-
swig/perl/t/DOMNamedNodeMap.t | 20 +-
swig/perl/t/DOMNode.t | 15 +-
swig/perl/t/DOMNodeIterator.t | 16 +-
swig/perl/t/DOMNodeList.t | 30 +-
swig/perl/t/DOMParser.t | 15 +-
swig/perl/t/DOMPrint.t | 22 +-
swig/perl/t/DOMStringList.t | 58 +
swig/perl/t/DOMTreeWalker.t | 24 +-
swig/perl/t/DOMWriter.t | 15 +-
swig/perl/t/SAX2XMLReader.t | 42 +-
swig/perl/t/SAXException.t | 20 +-
swig/perl/t/SAXParser.t | 28 +-
swig/perl/t/TestUtils.pm | 2 +-
swig/perl/t/UTF8.t | 18 +-
swig/perl/t/XMLUni.t | 2 +-
swig/perl/xerces-swig-perl.hpp | 1350 +
74 files changed, 38484 insertions(+), 33801 deletions(-)
create mode 100644 swig/interfaces/Perl/Xerces_DOM-extra.pm
create mode 100644 swig/interfaces/Perl/dom-callback.i
rename swig/interfaces/{typemaps.i => Perl/dom-includes.i} (71%)
create mode 100644 swig/interfaces/Perl/includes.i
create mode 100644 swig/interfaces/Xerces_DOM.i
delete mode 100644 swig/interfaces/callback.i
create mode 100644 swig/interfaces/dom-includes.i
create mode 100644 swig/interfaces/includes.i
create mode 100644 swig/perl/DOM/DOM.pm
create mode 100644 swig/perl/DOM/Makefile.PL
create mode 100644 swig/perl/DOM/Xerces_DOM.cpp
rename swig/perl/Handler/{PerlEntityResolverHandler.i => PerlEntityResolverHandler.cpp} (72%)
rename swig/perl/Handler/{PerlNodeFilterCallbackHandler.i => PerlNodeFilterCallbackHandler.cpp} (72%)
create mode 100644 swig/perl/Transcoder/Makefile.PL
create mode 100644 swig/perl/Transcoder/Transcoder.cpp
create mode 100644 swig/perl/Transcoder/Transcoder.hpp
create mode 100644 swig/perl/Transcoder/XMLExceptionHandler.cpp
create mode 100644 swig/perl/Transcoder/XMLExceptionHandler.hpp
create mode 100644 swig/perl/t/00dom_module.t
create mode 100644 swig/perl/t/00module.t
create mode 100644 swig/perl/t/DOMStringList.t
create mode 100644 swig/perl/xerces-swig-perl.hpp
diff --git a/swig/interfaces/Perl/Xerces-extra.pm b/swig/interfaces/Perl/Xerces-extra.pm
index 05b30f3e8..170abca04 100644
--- a/swig/interfaces/Perl/Xerces-extra.pm
+++ b/swig/interfaces/Perl/Xerces-extra.pm
@@ -4,7 +4,7 @@ use strict;
use Carp;
use vars qw(@EXPORT_OK $VERSION %REMEMBER);
@EXPORT_OK = qw(error);
-$VERSION = 260.2;
+$VERSION = 300.060829;
#
# Cleanup removes all objects being remembered by an object
@@ -630,28 +630,6 @@ sub to_hash {
return %hash;
}
-package XML::Xerces::DOMNodeList;
-# convert the NodeList to a perl list
-sub to_list {
- my $self = shift;
- my @list;
- for (my $i=0;$i<$self->getLength();$i++) {
- push(@list,$self->item($i));
- }
- return @list;
-}
-
-package XML::Xerces::DOMStringList;
-# convert the StringList to a perl list
-sub to_list {
- my $self = shift;
- my @list;
- for (my $i=0;$i<$self->getLength();$i++) {
- push(@list,$self->item($i));
- }
- return @list;
-}
-
package XML::Xerces::Attributes;
sub to_hash {
my $self = shift;
@@ -676,186 +654,6 @@ sub to_hash {
return %hash;
}
-package XML::Xerces::DOMNamedNodeMap;
-# convert the NamedNodeMap to a perl hash
-sub to_hash {
- my $self = shift;
- my @list;
- for (my $i=0;$i<$self->getLength();$i++) {
- my $node = $self->item($i);
- push(@list, $node->to_hash());
- }
- return @list;
-}
-
-package XML::Xerces::DOMNode;
-sub to_hash {
- my $self = shift;
- return ($self->getNodeName,$self->getNodeValue);
-}
-
-sub quote_content {
- my ($self,$node_value) = @_;
-
- $node_value =~ s/&/&/g;
- $node_value =~ s/</</g;
- $node_value =~ s/>/>/g;
- $node_value =~ s/\"/"/g;
- $node_value =~ s/\'/'/g;
-
- return $node_value;
-}
-
-package XML::Xerces::DOMEntity;
-sub to_hash {
- my $self = shift;
- if ($self->hasChildNodes) {
- return ($self->getNodeName(),
- $self->getFirstChild->getNodeValue());
- } else {
- return ($self->getNodeName(), '');
- }
-}
-
-package XML::Xerces::DOMText;
-sub serialize {
- return $_[0]->quote_content($_[0]->getNodeValue);
-}
-
-package XML::Xerces::DOMProcessingInstruction;
-sub serialize {
- my $output .= '<?' . $_[0]->getNodeName;
- if (length(my $str = $_[0]->getNodeValue)) {
- $output .= " $str";
- }
- $output .= '?>';
- return $output;
-}
-
-package XML::Xerces::DOMDocument;
-sub serialize {
- my $output;
- my $indent = 2;
- for(my $child = $_[0]->getFirstChild() ;
- defined $child ;
- $child = $child->getNextSibling())
- {
- $output .= $child->serialize($indent);
- }
- return "$output\n";
-}
-
-package XML::Xerces::DOMElement;
-sub serialize {
- my ($self,$indent) = @_;
- $indent ||= 0;
- my $output;
- ELEMENT: {
- my $node_name = $self->getNodeName;
- $output .= "<$node_name";
-
- my $attributes = $self->getAttributes;
- my $attribute_count = $attributes->getLength;
-
- for(my $ix = 0 ; $ix < $attribute_count ; ++$ix) {
- my $attribute = $attributes->item($ix);
- $output .= ' ' . $attribute->getNodeName . '="' . $self->quote_content($attribute->getNodeValue) . '"';
- }
-
- my $child = $self->getFirstChild();
- if (!defined $child) {
- $output .= '/>';
- last ELEMENT;
- }
-
- $output .= '>';
- while (defined $child) {
- $output .= $child->serialize($indent+2);
- $child = $child->getNextSibling();
- }
- $output .= "</$node_name>";
- }
- return $output;
-}
-
-package XML::Xerces::DOMEntityReference;
-sub serialize {
- my ($self) = @_;
- my $output;
- for(my $child = $self->getFirstChild() ;
- defined $child;
- $child = $child->getNextSibling())
- {
- $output .= $child->serialize();
- }
- return $output;
-}
-
-package XML::Xerces::DOMCDATASection;
-sub serialize {
- return '<![CDATA[' . $_[0]->getNodeValue . ']]>';
-}
-
-package XML::Xerces::DOMComment;
-sub serialize {
- return '<!--' . $_[0]->getNodeValue . "-->\n";
-}
-
-package XML::Xerces::DOMDocumentType;
-sub serialize {
- my $output;
- $output .= '<!DOCTYPE ' . $_[0]->getNodeName;
-
- my $id;
- if ($id = $_[0]->getPublicId) {
- $output .= qq[ PUBLIC "$id"];
- if ($id = $_[0]->getSystemId) {
- $output .= qq[ "$id"];
- }
- } elsif ($id = $_[0]->getSystemId) {
- $output .= qq[ SYSTEM "$id"];
- }
-
- if ($id = $_[0]->getInternalSubset) {
- $output .= " [$id]";
- }
-
- $output .= ">\n";
- return $output;
-}
-
-package XML::Xerces::DOMEntity;
-sub serialize {
- my $output;
- $output .= '<!ENTITY ' . $_[0]->getNodeName;
-
- my $id;
- if ($id = $_[0]->getPublicId) { $output .= qq[ PUBLIC "$id"]; }
- if ($id = $_[0]->getSystemId) { $output .= qq[ SYSTEM "$id"]; }
- if ($id = $_[0]->getNotationName) { $output .= qq[ NDATA "$id"]; }
-
- $output .= '>';
- return $output;
-}
-
-package XML::Xerces::DOMException;
-sub getMessage {
- return shift->{msg};
-}
-
-sub getCode {
- return shift->{code};
-}
-
-# in previous versions we needed to define this method
-# but it is now obsolete
-package XML::Xerces::DOMElement;
-sub get_text {
- my $self = shift;
- warn "XML::Xerces::DOMElement::get_text is depricated, use getTextContent instead";
- return $self->getTextContent(@_);
-}
-
package XML::Xerces::XMLCatalogResolver;
use strict;
use Carp;
diff --git a/swig/interfaces/Perl/Xerces_DOM-extra.pm b/swig/interfaces/Perl/Xerces_DOM-extra.pm
new file mode 100644
index 000000000..4e119502f
--- /dev/null
+++ b/swig/interfaces/Perl/Xerces_DOM-extra.pm
@@ -0,0 +1,202 @@
+package XML::Xerces::DOMNodeList;
+# convert the NodeList to a perl list
+sub to_list {
+ my $self = shift;
+ my @list;
+ for (my $i=0;$i<$self->getLength();$i++) {
+ push(@list,$self->item($i));
+ }
+ return @list;
+}
+
+package XML::Xerces::DOMStringList;
+# convert the StringList to a perl list
+sub to_list {
+ my $self = shift;
+ my @list;
+ for (my $i=0;$i<$self->getLength();$i++) {
+ push(@list,$self->item($i));
+ }
+ return @list;
+}
+
+package XML::Xerces::DOMNamedNodeMap;
+# convert the NamedNodeMap to a perl hash
+sub to_hash {
+ my $self = shift;
+ my @list;
+ for (my $i=0;$i<$self->getLength();$i++) {
+ my $node = $self->item($i);
+ push(@list, $node->to_hash());
+ }
+ return @list;
+}
+
+package XML::Xerces::DOMNode;
+sub to_hash {
+ my $self = shift;
+ return ($self->getNodeName,$self->getNodeValue);
+}
+
+sub quote_content {
+ my ($self,$node_value) = @_;
+
+ $node_value =~ s/&/&/g;
+ $node_value =~ s/</</g;
+ $node_value =~ s/>/>/g;
+ $node_value =~ s/\"/"/g;
+ $node_value =~ s/\'/'/g;
+
+ return $node_value;
+}
+
+package XML::Xerces::DOMEntity;
+sub to_hash {
+ my $self = shift;
+ if ($self->hasChildNodes) {
+ return ($self->getNodeName(),
+ $self->getFirstChild->getNodeValue());
+ } else {
+ return ($self->getNodeName(), '');
+ }
+}
+
+package XML::Xerces::DOMText;
+sub serialize {
+ return $_[0]->quote_content($_[0]->getNodeValue);
+}
+
+package XML::Xerces::DOMProcessingInstruction;
+sub serialize {
+ my $output .= '<?' . $_[0]->getNodeName;
+ if (length(my $str = $_[0]->getNodeValue)) {
+ $output .= " $str";
+ }
+ $output .= '?>';
+ return $output;
+}
+
+package XML::Xerces::DOMDocument;
+sub serialize {
+ my $output;
+ my $indent = 2;
+ for(my $child = $_[0]->getFirstChild() ;
+ defined $child ;
+ $child = $child->getNextSibling())
+ {
+ $output .= $child->serialize($indent);
+ }
+ return "$output\n";
+}
+
+package XML::Xerces::DOMElement;
+sub serialize {
+ my ($self,$indent) = @_;
+ $indent ||= 0;
+ my $output;
+ ELEMENT: {
+ my $node_name = $self->getNodeName;
+ $output .= "<$node_name";
+
+ my $attributes = $self->getAttributes;
+ my $attribute_count = $attributes->getLength;
+
+ for(my $ix = 0 ; $ix < $attribute_count ; ++$ix) {
+ my $attribute = $attributes->item($ix);
+ $output .= ' ' . $attribute->getNodeName . '="' . $self->quote_content($attribute->getNodeValue) . '"';
+ }
+
+ my $child = $self->getFirstChild();
+ if (!defined $child) {
+ $output .= '/>';
+ last ELEMENT;
+ }
+
+ $output .= '>';
+ while (defined $child) {
+ $output .= $child->serialize($indent+2);
+ $child = $child->getNextSibling();
+ }
+ $output .= "</$node_name>";
+ }
+ return $output;
+}
+
+package XML::Xerces::DOMEntityReference;
+sub serialize {
+ my ($self) = @_;
+ my $output;
+ for(my $child = $self->getFirstChild() ;
+ defined $child;
+ $child = $child->getNextSibling())
+ {
+ $output .= $child->serialize();
+ }
+ return $output;
+}
+
+package XML::Xerces::DOMCDATASection;
+sub serialize {
+ return '<![CDATA[' . $_[0]->getNodeValue . ']]>';
+}
+
+package XML::Xerces::DOMComment;
+sub serialize {
+ return '<!--' . $_[0]->getNodeValue . "-->\n";
+}
+
+package XML::Xerces::DOMDocumentType;
+sub serialize {
+ my $output;
+ $output .= '<!DOCTYPE ' . $_[0]->getNodeName;
+
+ my $id;
+ if ($id = $_[0]->getPublicId) {
+ $output .= qq[ PUBLIC "$id"];
+ if ($id = $_[0]->getSystemId) {
+ $output .= qq[ "$id"];
+ }
+ } elsif ($id = $_[0]->getSystemId) {
+ $output .= qq[ SYSTEM "$id"];
+ }
+
+ if ($id = $_[0]->getInternalSubset) {
+ $output .= " [$id]";
+ }
+
+ $output .= ">\n";
+ return $output;
+}
+
+package XML::Xerces::DOMEntity;
+sub serialize {
+ my $output;
+ $output .= '<!ENTITY ' . $_[0]->getNodeName;
+
+ my $id;
+ if ($id = $_[0]->getPublicId) { $output .= qq[ PUBLIC "$id"]; }
+ if ($id = $_[0]->getSystemId) { $output .= qq[ SYSTEM "$id"]; }
+ if ($id = $_[0]->getNotationName) { $output .= qq[ NDATA "$id"]; }
+
+ $output .= '>';
+ return $output;
+}
+
+package XML::Xerces::DOMException;
+sub getMessage {
+ return shift->{msg};
+}
+
+sub getCode {
+ return shift->{code};
+}
+
+# in previous versions we needed to define this method
+# but it is now obsolete
+package XML::Xerces::DOMElement;
+sub get_text {
+ my $self = shift;
+ warn "XML::Xerces::DOMElement::get_text is depricated, use getTextContent instead";
+ return $self->getTextContent(@_);
+}
+
diff --git a/swig/interfaces/Perl/callback.i b/swig/interfaces/Perl/callback.i
index 969753043..51006ff68 100644
--- a/swig/interfaces/Perl/callback.i
+++ b/swig/interfaces/Perl/callback.i
@@ -19,6 +19,14 @@
*
*/
+%include "PerlCallbackHandler.hpp"
+%include "PerlErrorCallbackHandler.hpp"
+%include "PerlEntityResolverHandler.hpp"
+%include "PerlDocumentCallbackHandler.hpp"
+%include "PerlContentCallbackHandler.hpp"
+
+// %include "PerlNodeFilterCallbackHandler.hpp"
+
/*
* PerlCallbackHandler* - this is broken and useless
*/
diff --git a/swig/interfaces/Perl/defines.i b/swig/interfaces/Perl/defines.i
index af7b53bf9..c3f6fe25a 100644
--- a/swig/interfaces/Perl/defines.i
+++ b/swig/interfaces/Perl/defines.i
@@ -21,13 +21,6 @@
%{
-#include "PerlCallbackHandler.hpp"
-#include "PerlErrorCallbackHandler.hpp"
-#include "PerlDocumentCallbackHandler.hpp"
-#include "PerlContentCallbackHandler.hpp"
-#include "PerlEntityResolverHandler.i"
-#include "PerlNodeFilterCallbackHandler.i"
-
static void
SWIG_Disown(SV *sv) {
diff --git a/swig/interfaces/Perl/dom-callback.i b/swig/interfaces/Perl/dom-callback.i
new file mode 100644
index 000000000..1e6003953
--- /dev/null
+++ b/swig/interfaces/Perl/dom-callback.i
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Perl/callback.i - an experimental typecheck for returning callback subclasses
+ *
+ */
+
+%import "PerlCallbackHandler.hpp"
+%include "PerlNodeFilterCallbackHandler.hpp"
+
+/*
+ * PerlCallbackHandler* - this is broken and useless
+ */
+
+/*
+%typemap(out) XERCES_CPP_NAMESPACE::PerlCallbackHandler * = SWIGTYPE *DYNAMIC;
+
+DYNAMIC_CAST(SWIGTYPE_p_PerlCallbackHandler, PerlCallbackHandler_dynamic_cast);
+
+%{
+
+static swig_type_info *
+PerlCallbackHandler_dynamic_cast(void **ptr) {
+ PerlCallbackHandler **nptr = (PerlCallbackHandler **) ptr;
+ if (*nptr == NULL) {
+ return NULL;
+ }
+ short int type = (*nptr)->type();
+ if (type == PERLCALLBACKHANDLER_BASE_TYPE) {
+ die("Can't cast a PerlCallbackHandler base type node\n");
+ }
+ if (type == PERLCALLBACKHANDLER_ERROR_TYPE) {
+ return SWIGTYPE_p_PerlErrorCallbackHandler;
+ }
+ if (type == PERLCALLBACKHANDLER_ENTITY_TYPE) {
+ return SWIGTYPE_p_PerlEntityResolverHandler;
+ }
+ if (type == PERLCALLBACKHANDLER_CONTENT_TYPE) {
+ return SWIGTYPE_p_PerlContentCallbackHandler;
+ }
+ if (type == PERLCALLBACKHANDLER_DOCUMENT_TYPE) {
+ return SWIGTYPE_p_PerlDocumentCallbackHandler;
+ }
+ if (type == PERLCALLBACKHANDLER_NODE_TYPE) {
+ return SWIGTYPE_p_PerlNodeFilterCallbackHandler;
+ }
+ return NULL;
+}
+
+%}
+*/
\ No newline at end of file
diff --git a/swig/interfaces/typemaps.i b/swig/interfaces/Perl/dom-includes.i
similarity index 71%
rename from swig/interfaces/typemaps.i
rename to swig/interfaces/Perl/dom-includes.i
index 6d3a0fd69..5ec5fa7a9 100644
--- a/swig/interfaces/typemaps.i
+++ b/swig/interfaces/Perl/dom-includes.i
@@ -14,18 +14,13 @@
* limitations under the License.
*/
-/**************/
-/* */
-/* TYPEMAPS */
-/* */
-/**************/
+/*
+ * Perl/includes.i - all #includes needed for Xerces.cpp
+ *
+ */
-%include typemaps-general.i
+%{
-#ifdef SWIGPERL
-%include "Perl/typemaps.i"
-%include "Perl/typemaps-xmlch.i"
-#endif
+#include "PerlNodeFilterCallbackHandler.hpp"
-// this is new for Xerces-3
-%apply size_t { ssize_t };
\ No newline at end of file
+%}
\ No newline at end of file
diff --git a/swig/interfaces/Perl/dom-shadow.i b/swig/interfaces/Perl/dom-shadow.i
index 8a6c2faaa..74ec9d447 100644
--- a/swig/interfaces/Perl/dom-shadow.i
+++ b/swig/interfaces/Perl/dom-shadow.i
@@ -56,6 +56,7 @@ DOMLIST_METHOD(DOMDocument,getElementsByTagNameNS)
DOMLIST_METHOD(DOMElement,getElementsByTagName)
DOMLIST_METHOD(DOMElement,getElementsByTagNameNS)
DOMLIST_METHOD(DOMNode,getChildNodes)
+DOMLIST_METHOD(DOMConfiguration,getParameterNames)
// Define a macro to rewrite all methods that return a map of DOMNodes
diff --git a/swig/interfaces/Perl/errors.i b/swig/interfaces/Perl/errors.i
index 596eb2f9f..8ed3a2678 100644
--- a/swig/interfaces/Perl/errors.i
+++ b/swig/interfaces/Perl/errors.i
@@ -1,4 +1,7 @@
%{
+
+#define SWIG_SetErrorf SWIG_Perl_SetErrorf
+
static void
SWIG_Perl_SetErrorf(const char *fmt, ...) {
va_list args;
diff --git a/swig/interfaces/Perl/includes.i b/swig/interfaces/Perl/includes.i
new file mode 100644
index 000000000..0834305b0
--- /dev/null
+++ b/swig/interfaces/Perl/includes.i
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Perl/includes.i - all #includes needed for Xerces.cpp
+ *
+ */
+
+%{
+
+#include "Transcoder.hpp"
+#include "XMLExceptionHandler.hpp"
+
+#include "PerlCallbackHandler.hpp"
+#include "PerlErrorCallbackHandler.hpp"
+#include "PerlDocumentCallbackHandler.hpp"
+#include "PerlContentCallbackHandler.hpp"
+#include "PerlEntityResolverHandler.hpp"
+
+%}
\ No newline at end of file
diff --git a/swig/interfaces/Perl/typemaps-xmlch.i b/swig/interfaces/Perl/typemaps-xmlch.i
index 423089319..782ff330d 100644
--- a/swig/interfaces/Perl/typemaps-xmlch.i
+++ b/swig/interfaces/Perl/typemaps-xmlch.i
@@ -46,7 +46,7 @@
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- $1 = Perl2XMLString($input);
+ $1 = UTF8_TRANSCODER->Perl2XMLString($input);
}
%}
@@ -56,23 +56,46 @@
// out typemap
%typemap(out) XMLCh * %{
- $result = XMLString2Perl($1);
+ $result = UTF8_TRANSCODER->XMLString2Perl($1);
++argvi;
%}
// varout typemap (for global variables)
// useful for XMLUni constants
%typemap(varout) XMLCh[] %{
- sv_setsv((SV*)$result, XMLString2Perl($1));
+ sv_setsv((SV*)$result, UTF8_TRANSCODER->XMLString2Perl($1));
%}
// fgBooleanValueSpace is an array of XMLCh*
%typemap(varout) XMLCh[][8] %{
AV *myav = newAV();
for (int i=0;i<4;i++) {
- av_push(myav, XMLString2Perl($1[i]));
+ av_push(myav, UTF8_TRANSCODER->XMLString2Perl($1[i]));
}
SV* rv = newRV((SV*)myav);
sv_setsv((SV*)$result, rv);
%}
+
+/*
+ * Enable conversion of void* => XMLCh* in setProperty()
+ *
+ * The in typemap converts the void* to an XMLCh*
+ *
+ * The freearg typemap deletes the transcoded string
+ *
+ */
+%typemap(in) (void* value) {
+ // now check the value
+ if ($input == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",$argnum,"$symname");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ $1 = UTF8_TRANSCODER->Perl2XMLString($input);
+ }
+}
+%typemap(freearg) void * %{
+ delete[] $1;
+%}
+
diff --git a/swig/interfaces/Perl/typemaps.i b/swig/interfaces/Perl/typemaps.i
index f43c92af7..43122ddb2 100644
--- a/swig/interfaces/Perl/typemaps.i
+++ b/swig/interfaces/Perl/typemaps.i
@@ -24,8 +24,9 @@
}
// XMLByte arrays are just unisgned char*'s
-%typemap(out) const XMLByte* getRawBuffer() {
- %set_output(SWIG_FromCharPtr((char*)result));
+// force loading of FromCharPtr fragment - needed for DOM
+%typemap(out, noblock=1, fragment="SWIG_FromCharPtr") const XMLByte* getRawBuffer() {
+ %set_output(SWIG_FromCharPtr((char*)$1));
}
/*
diff --git a/swig/interfaces/Xerces.i b/swig/interfaces/Xerces.i
index 987eaed1b..0127b3e04 100644
--- a/swig/interfaces/Xerces.i
+++ b/swig/interfaces/Xerces.i
@@ -29,22 +29,44 @@
%module "XML::Xerces"
#endif
-%include "defines.i"
-
-%include "typemaps.i"
-
-%include "typemaps-dom.i"
+%include "includes.i"
/*
- * Import the language specific macros
+ * Import the language specific macros - not namespace dependent
+ * we place these first so that they can define any master
+ * macros needed by the language-independent interface files
*/
#ifdef SWIGPERL
-%include "Perl/callback.i"
%include "Perl/shadow.i"
-%include "Perl/dom-shadow.i"
+// %include "Perl/dom-shadow.i"
+%include "Perl/defines.i"
+%include "Perl/errors.i"
+%include "Perl/includes.i"
+%include "Perl/typemaps.i"
+%include "Perl/typemaps-xmlch.i"
#endif
+/*
+ * Start the XERCES_CPP_NAMESPACE
+ * after this everything will be in Xerces namespace
+ */
+%include "defines.i"
+
+/*
+ * language dependent features that are namespace dependent
+ * such as the transcoders
+ *
+ */
+#ifdef SWIGPERL
+// %include "Perl/transcode.i"
+#endif
+
+
+%include typemaps-general.i
+
+// %include "typemaps-dom.i"
+
/*****************************/
/* */
/* Platforms and Compilers */
@@ -142,7 +164,7 @@
* DOM
*/
-%include "DOM.i"
+// %include "DOM.i"
// %include "xercesc/dom/DOMNode.hpp"
@@ -164,33 +186,33 @@
%include "parsers.i"
-/*
- * Callbacks - this needs to be at the very end
- * so that SWIG can wrap the superclass methods properly
- */
-
-%include "callback.i"
-
/*
* Include extra verbatim C code in the initialization function
*/
%init {
// we create the global transcoder for UTF-8 to UTF-16
- XMLTransService::Codes failReason;
- XMLPlatformUtils::Initialize(); // first we must create the transservice
- UTF8_ENCODING = XMLString::transcode("UTF-8");
- UTF8_TRANSCODER =
- XMLPlatformUtils::fgTransService->makeNewTranscoderFor(UTF8_ENCODING,
- failReason,
- 1024,
- XMLPlatformUtils::fgMemoryManager);
+ // must initialize the Xerces-C transcoding service
+ XMLPlatformUtils::Initialize();
+ UTF8_TRANSCODER = Transcoder::getInstance();
if (! UTF8_TRANSCODER) {
croak("ERROR: XML::Xerces: INIT: Could not create UTF-8 transcoder");
}
+
+ XML_EXCEPTION_HANDLER = XMLExceptionHandler::getInstance();
+ if (! XML_EXCEPTION_HANDLER) {
+ croak("ERROR: XML::Xerces: INIT: Could not create XMLExceptionHandler");
+ }
}
#ifdef SWIGPERL
+/*
+ * Callbacks - this needs to be at the very end
+ * so that SWIG can wrap the superclass methods properly
+ */
+
+%include "Perl/callback.i"
+
/*
* Include extra verbatim Perl code
*/
diff --git a/swig/interfaces/Xerces_DOM.i b/swig/interfaces/Xerces_DOM.i
new file mode 100644
index 000000000..1247138a6
--- /dev/null
+++ b/swig/interfaces/Xerces_DOM.i
@@ -0,0 +1,272 @@
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * All DOM classes and their related SWIG alterations go in this interface file
+ */
+
+/*
+ * Modulename - this *must* be in double quotes to properly handle
+ * the namespace
+ */
+#ifdef SWIGPERL
+%module(package="XML::Xerces") "DOM"
+// %module "XML::Xerces::DOM"
+#endif
+
+%include "includes.i"
+
+%include "dom-includes.i"
+
+/*
+ * Import the language specific macros
+ */
+
+#ifdef SWIGPERL
+%include "Perl/errors.i"
+%include "Perl/defines.i"
+%include "Perl/dom-shadow.i"
+%include "Perl/typemaps.i"
+%include "Perl/typemaps-xmlch.i"
+%include "Perl/includes.i"
+%include "Perl/dom-includes.i"
+#endif
+
+// Get the type information
+%import "Xerces.i"
+
+/*
+ * After this we will be under the Xerces namespace
+ *
+ */
+
+%{
+
+XERCES_CPP_NAMESPACE_USE
+
+// we initialize the static UTF-8 transcoding info
+// these are used by the typemaps to convert between
+// Xerces internal UTF-16 and Perl's internal UTF-8
+static Transcoder* UTF8_TRANSCODER = NULL;
+
+static XMLExceptionHandler* XML_EXCEPTION_HANDLER = NULL;
+
+void
+makeXMLException(const XMLException& e){
+ SV *error = ERRSV;
+ SWIG_MakePtr(error, (void *) XML_EXCEPTION_HANDLER->copyXMLException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLException, SWIG_SHADOW|0);
+}
+
+void
+makeDOMException(const DOMException& e){
+ SV *error = ERRSV;
+ SWIG_MakePtr(error, (void *) new DOMException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_SHADOW|0);
+}
+
+%}
+
+// %include "make-xml-exception.i"
+
+%include "typemaps-dom.i"
+
+%include "typemaps-general.i"
+
+/*****************************/
+/* */
+/* Platforms and Compilers */
+/* */
+/*****************************/
+
+// we seem to need these defs loaded before parsing XercesDefs.hpp
+// as of Xerces-3.0
+%import "xercesc/util/Xerces_autoconf_config.hpp" // for XMLSize_t and namespaces
+
+%import "xercesc/util/XercesDefs.hpp"
+
+/*
+ * All %ignore directives
+ */
+
+%include "ignore.i"
+
+/*
+ * Operator support
+ */
+
+// Operators we do want
+// %rename(operator_assignment) operator=;
+%rename(operator_equal_to) operator==;
+%rename(operator_not_equal_to) operator!=;
+
+
+/*
+ * the DOM classes gets a special exception handler
+ * 'goto fail' must be called - either explicitly, or via SWIG_croak()
+ * to ensure that any variable cleanup is done - to avoid memory leaks.
+ * By making these macros, it reduces the code *file* size dramatically
+ * (but doesn't reduce the compiled file size at all...)
+ */
+
+%{
+#define CATCH_DOM_EXCEPTION \
+ catch (const XMLException& e) \
+ { \
+ makeXMLException(e); \
+ goto fail; \
+ } \
+ catch (const DOMException& e) \
+ { \
+ makeDOMException(e); \
+ goto fail; \
+ } \
+ catch (...) \
+ { \
+ SWIG_croak("Handling Unknown exception"); \
+ goto fail; \
+ }
+%}
+
+%exception {
+ try
+ {
+ $action
+ }
+ CATCH_DOM_EXCEPTION
+}
+
+
+// Introduced in DOM Level 1
+%include "dom/DOMException.i"
+%include "dom/DOMNode.i"
+%include "dom/DOMAttr.i"
+%include "dom/DOMElement.i"
+%include "dom/DOMEntity.i"
+%include "dom/DOMDocumentType.i"
+%include "dom/DOMCharacterData.i"
+%include "dom/DOMComment.i"
+%include "dom/DOMText.i"
+%include "dom/DOMCDATASection.i"
+%include "dom/DOMNodeList.i"
+%include "dom/DOMNamedNodeMap.i"
+%include "dom/DOMDocumentFragment.i"
+%include "dom/DOMEntityReference.i"
+%include "dom/DOMNotation.i"
+%include "dom/DOMProcessingInstruction.i"
+
+// type info
+%include "dom/DOMTypeInfo.i"
+%include "dom/DOMPSVITypeInfo.i"
+
+// XPath
+%include "dom/DOMXPathEvaluator.i"
+%include "dom/DOMXPathException.i"
+%include "dom/DOMXPathExpression.i"
+%include "dom/DOMXPathNamespace.i"
+%include "dom/DOMXPathNSResolver.i"
+%include "dom/DOMXPathResult.i"
+
+// Introduced in DOM Level 2
+%include "dom/DOMDocumentRange.i"
+%include "dom/DOMDocumentTraversal.i"
+%include "dom/DOMNodeIterator.i"
+%include "dom/DOMNodeFilter.i"
+%include "dom/DOMRange.i"
+%include "dom/DOMRangeException.i"
+%include "dom/DOMTreeWalker.i"
+
+/*
+ * Introduced in DOM Level 3
+ */
+%include "dom/DOMUserDataHandler.i"
+%include "dom/DOMConfiguration.i"
+%include "dom/DOMStringList.i"
+%include "dom/DOMImplementationLS.i"
+%include "dom/DOMImplementation.i"
+%include "dom/DOMImplementationList.i"
+%include "dom/DOMImplementationSource.i"
+%include "dom/DOMImplementationRegistry.i"
+
+%include "dom/DOMError.i"
+%include "dom/DOMErrorHandler.i"
+%include "dom/DOMDocument.i"
+%include "dom/DOMLocator.i"
+%include "dom/DOMLSResourceResolver.i"
+
+// DOMLSParser
+%include "dom/DOMLSInput.i"
+%include "framework/Wrapper4InputSource.i"
+%include "framework/Wrapper4DOMLSInput.i"
+%include "dom/DOMLSParserFilter.i"
+%include "dom/DOMLSParser.i"
+
+// DOMWriter
+%include "dom/DOMLSOutput.i"
+%include "framework/XMLFormatter.i"
+%include "framework/StdOutFormatTarget.i"
+%include "framework/LocalFileFormatTarget.i"
+%include "framework/MemBufFormatTarget.i"
+
+%include "dom/DOMLSException.i"
+%include "dom/DOMLSSerializer.i"
+%include "dom/DOMLSSerializerFilter.i"
+
+%import "xercesc/framework/XMLPScanToken.hpp"
+%import "xercesc/framework/psvi/PSVIHandler.hpp"
+
+%include "parsers/AbstractDOMParser.i"
+%include "parsers/XercesDOMParser.i"
+
+/*
+ * Include extra verbatim C code in the initialization function
+ */
+%init {
+ // we create the global transcoder for UTF-8 to UTF-16
+ // must initialize the Xerces-C transcoding service
+ XMLPlatformUtils::Initialize();
+ UTF8_TRANSCODER = Transcoder::getInstance();
+ if (! UTF8_TRANSCODER) {
+ croak("ERROR: XML::Xerces: INIT: Could not create UTF-8 transcoder");
+ }
+
+ XML_EXCEPTION_HANDLER = XMLExceptionHandler::getInstance();
+ if (! XML_EXCEPTION_HANDLER) {
+ croak("ERROR: XML::Xerces: INIT: Could not create XMLExceptionHandler");
+ }
+}
+
+#ifdef SWIGPERL
+
+/*
+ * Callbacks - this needs to be at the very end
+ * so that SWIG can wrap the superclass methods properly
+ */
+
+%include "Perl/dom-callback.i"
+
+/*
+ * Include extra verbatim Perl code
+ */
+%pragma(perl5) include="../../interfaces/Perl/Xerces_DOM-extra.pm"
+
+/*
+ * Include extra verbatim Perl code immediately after Module header
+ */
+
+%pragma(perl5) code="package XML::Xerces::DOM;
+use XML::Xerces;
+use vars qw($VERSION @EXPORT);"
+
+#endif
diff --git a/swig/interfaces/callback.i b/swig/interfaces/callback.i
deleted file mode 100644
index 22ea9de3e..000000000
--- a/swig/interfaces/callback.i
+++ /dev/null
@@ -1,7 +0,0 @@
-%include "PerlCallbackHandler.hpp"
-%include "PerlErrorCallbackHandler.hpp"
-%include "PerlEntityResolverHandler.hpp"
-%include "PerlNodeFilterCallbackHandler.hpp"
-%include "PerlDocumentCallbackHandler.hpp"
-%include "PerlContentCallbackHandler.hpp"
-
diff --git a/swig/interfaces/defines.i b/swig/interfaces/defines.i
index 46765254d..e552412c0 100644
--- a/swig/interfaces/defines.i
+++ b/swig/interfaces/defines.i
@@ -20,214 +20,32 @@
*/
%{
-#include "xercesc/sax/InputSource.hpp"
-#include "xercesc/sax/SAXException.hpp"
-#include "xercesc/sax/SAXParseException.hpp"
-#include "xercesc/sax/Locator.hpp"
-#include "xercesc/sax/HandlerBase.hpp"
-#include "xercesc/sax2/Attributes.hpp"
-#include "xercesc/sax2/ContentHandler.hpp"
-#include "xercesc/sax2/LexicalHandler.hpp"
-#include "xercesc/sax2/DefaultHandler.hpp"
-#include "xercesc/sax2/SAX2XMLReader.hpp"
-#include "xercesc/sax2/XMLReaderFactory.hpp"
-#include "xercesc/util/PlatformUtils.hpp"
-#include "xercesc/util/TransService.hpp"
-#include "xercesc/util/XMLString.hpp"
-#include "xercesc/util/XMLUri.hpp"
-#include "xercesc/util/QName.hpp"
-#include "xercesc/util/HexBin.hpp"
-#include "xercesc/util/Base64.hpp"
-#include "xercesc/parsers/SAXParser.hpp"
-#include "xercesc/framework/LocalFileInputSource.hpp"
-#include "xercesc/framework/MemBufInputSource.hpp"
-#include "xercesc/framework/StdInInputSource.hpp"
-#include "xercesc/framework/URLInputSource.hpp"
-#include "xercesc/framework/XMLGrammarDescription.hpp"
-#include "xercesc/framework/XMLDTDDescription.hpp"
-#include "xercesc/framework/XMLSchemaDescription.hpp"
-#include "xercesc/util/NameIdPool.hpp"
-#include "xercesc/util/XMLEnumerator.hpp"
-#include "xercesc/framework/XMLValidator.hpp"
-#include "xercesc/validators/common/Grammar.hpp"
-#include "xercesc/validators/DTD/DTDAttDef.hpp"
-#include "xercesc/validators/DTD/DTDAttDefList.hpp"
-#include "xercesc/validators/DTD/DTDGrammar.hpp"
-#include "xercesc/validators/DTD/DTDValidator.hpp"
-#include "xercesc/validators/schema/SchemaGrammar.hpp"
-#include "xercesc/validators/schema/SchemaValidator.hpp"
-#include "xercesc/validators/schema/SchemaAttDefList.hpp"
-#include "xercesc/validators/schema/SchemaAttDef.hpp"
-#include "xercesc/framework/XMLFormatter.hpp"
-#include "xercesc/framework/MemBufFormatTarget.hpp"
-#include "xercesc/framework/LocalFileFormatTarget.hpp"
-#include "xercesc/framework/StdOutFormatTarget.hpp"
-#include "xercesc/framework/psvi/PSVIHandler.hpp"
-
-// for resolving XMLExceptions
-#include "xercesc/util/ArrayIndexOutOfBoundsException.hpp"
-#include "xercesc/util/EmptyStackException.hpp"
-#include "xercesc/util/IllegalArgumentException.hpp"
-#include "xercesc/util/InvalidCastException.hpp"
-#include "xercesc/util/IOException.hpp"
-#include "xercesc/util/NoSuchElementException.hpp"
-#include "xercesc/util/NullPointerException.hpp"
-#include "xercesc/util/NumberFormatException.hpp"
-#include "xercesc/util/ParseException.hpp"
-#include "xercesc/util/RuntimeException.hpp"
-#include "xercesc/util/SchemaDateTimeException.hpp"
-#include "xercesc/util/TranscodingException.hpp"
-#include "xercesc/util/UnexpectedEOFException.hpp"
-#include "xercesc/util/UnsupportedEncodingException.hpp"
-#include "xercesc/util/UTFDataFormatException.hpp"
-#include "xercesc/util/XMLNetAccessor.hpp"
-#include "xercesc/internal/XSerializationException.hpp"
-#include "xercesc/validators/datatype/InvalidDatatypeFacetException.hpp"
-#include "xercesc/validators/datatype/InvalidDatatypeValueException.hpp"
-#include "xercesc/validators/schema/identity/XPathException.hpp"
-
-//
-// DOM stuff - wants to be moved to seperate module
-//
-#include "xercesc/dom/DOM.hpp"
-#include "xercesc/framework/Wrapper4InputSource.hpp"
-#include "xercesc/framework/Wrapper4DOMLSInput.hpp"
-#include "xercesc/parsers/AbstractDOMParser.hpp"
-#include "xercesc/parsers/XercesDOMParser.hpp"
-
-// need this for PerlNodeFilterCallbackHandler
-// #include "xercesc/dom/DOMNode.hpp"
XERCES_CPP_NAMESPACE_USE
// we initialize the static UTF-8 transcoding info
// these are used by the typemaps to convert between
// Xerces internal UTF-16 and Perl's internal UTF-8
-static XMLCh* UTF8_ENCODING = NULL;
-static XMLTranscoder* UTF8_TRANSCODER = NULL;
+static Transcoder* UTF8_TRANSCODER = NULL;
+
+static XMLExceptionHandler* XML_EXCEPTION_HANDLER = NULL;
static bool DEBUG_UTF8_OUT = 0;
static bool DEBUG_UTF8_IN = 0;
%}
-/*
- * Import the language specific includes
- */
-
-#ifdef SWIGPERL
-%include "Perl/defines.i"
-%include "Perl/transcode.i"
-%include "Perl/errors.i"
-#endif
-
-
// These get wrapped by SWIG so that we can modify them from the scripting language
bool DEBUG_UTF8_OUT;
bool DEBUG_UTF8_IN;
+
%{
-XMLException*
-copyXMLException(const XMLException& e)
-{
- if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgArrayIndexOutOfBoundsException_Name)
- {
- return (XMLException*)((ArrayIndexOutOfBoundsException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgEmptyStackException_Name)
- {
- return (XMLException*)((EmptyStackException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgIllegalArgumentException_Name)
- {
- return (XMLException*)((IllegalArgumentException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgInvalidCastException_Name)
- {
- return (XMLException*)((InvalidCastException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgIOException_Name)
- {
- return (XMLException*)((IOException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgNoSuchElementException_Name)
- {
- return (XMLException*)((NoSuchElementException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgNullPointerException_Name)
- {
- return (XMLException*)((NullPointerException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgNumberFormatException_Name)
- {
- return (XMLException*)((NumberFormatException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgParseException_Name)
- {
- return (XMLException*)((ParseException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgXMLPlatformUtilsException_Name)
- {
- return (XMLException*)((XMLPlatformUtilsException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgRuntimeException_Name)
- {
- return (XMLException*)((RuntimeException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgSchemaDateTimeException_Name)
- {
- return (XMLException*)((SchemaDateTimeException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgTranscodingException_Name)
- {
- return (XMLException*)((TranscodingException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgUnexpectedEOFException_Name)
- {
- return (XMLException*)((UnexpectedEOFException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgUnsupportedEncodingException_Name)
- {
- return (XMLException*)((UnsupportedEncodingException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgUTFDataFormatException_Name)
- {
- return (XMLException*)((UTFDataFormatException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgNetAccessorException_Name)
- {
- return (XMLException*)((NetAccessorException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgMalformedURLException_Name)
- {
- return (XMLException*)((MalformedURLException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgXSerializationException_Name)
- {
- return (XMLException*)((XSerializationException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgInvalidDatatypeFacetException_Name)
- {
- return (XMLException*)((InvalidDatatypeFacetException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgInvalidDatatypeValueException_Name)
- {
- return (XMLException*)((InvalidDatatypeValueException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgXPathException_Name)
- {
- return (XMLException*)((XPathException*)&e)->duplicate();
- }
- else
- {
- SWIG_Perl_SetErrorf("Unknown Exception type: %d", e.getType());
- }
-}
void
makeXMLException(const XMLException& e){
SV *error = ERRSV;
- SWIG_MakePtr(error, (void *) copyXMLException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLException, SWIG_SHADOW|0);
+ SWIG_MakePtr(error, (void *) XML_EXCEPTION_HANDLER->copyXMLException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLException, SWIG_SHADOW|0);
}
void
@@ -242,10 +60,6 @@ makeSAXNotSupportedException(const SAXNotSupportedException& e){
SWIG_MakePtr(error, (void *) new SAXNotSupportedException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, SWIG_SHADOW|0);
}
-void
-makeDOMException(const DOMException& e){
- SV *error = ERRSV;
- SWIG_MakePtr(error, (void *) new DOMException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_SHADOW|0);
-}
-
%}
+
+// %include "make-xml-exception.i"
diff --git a/swig/interfaces/dom-includes.i b/swig/interfaces/dom-includes.i
new file mode 100644
index 000000000..1c3d5544c
--- /dev/null
+++ b/swig/interfaces/dom-includes.i
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+%{
+#include "xercesc/dom/DOM.hpp"
+#include "xercesc/util/XMLException.hpp"
+#include "xercesc/framework/Wrapper4InputSource.hpp"
+#include "xercesc/framework/Wrapper4DOMLSInput.hpp"
+#include "xercesc/parsers/AbstractDOMParser.hpp"
+#include "xercesc/parsers/XercesDOMParser.hpp"
+#include "xercesc/framework/MemBufFormatTarget.hpp"
+#include "xercesc/framework/LocalFileFormatTarget.hpp"
+#include "xercesc/framework/StdOutFormatTarget.hpp"
+#include "xercesc/util/XMLUni.hpp"
+
+%}
+
diff --git a/swig/interfaces/includes.i b/swig/interfaces/includes.i
new file mode 100644
index 000000000..61de84915
--- /dev/null
+++ b/swig/interfaces/includes.i
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * includes.i - all the #includes needed for Xerces.cpp
+ */
+
+%{
+#include "xercesc/sax/InputSource.hpp"
+#include "xercesc/sax/SAXException.hpp"
+#include "xercesc/sax/SAXParseException.hpp"
+#include "xercesc/sax/Locator.hpp"
+#include "xercesc/sax/HandlerBase.hpp"
+#include "xercesc/sax2/Attributes.hpp"
+#include "xercesc/sax2/ContentHandler.hpp"
+#include "xercesc/sax2/LexicalHandler.hpp"
+#include "xercesc/sax2/DefaultHandler.hpp"
+#include "xercesc/sax2/SAX2XMLReader.hpp"
+#include "xercesc/sax2/XMLReaderFactory.hpp"
+#include "xercesc/util/PlatformUtils.hpp"
+#include "xercesc/util/TransService.hpp"
+#include "xercesc/util/XMLString.hpp"
+#include "xercesc/util/XMLUri.hpp"
+#include "xercesc/util/QName.hpp"
+#include "xercesc/util/HexBin.hpp"
+#include "xercesc/util/Base64.hpp"
+#include "xercesc/parsers/SAXParser.hpp"
+#include "xercesc/framework/LocalFileInputSource.hpp"
+#include "xercesc/framework/MemBufInputSource.hpp"
+#include "xercesc/framework/StdInInputSource.hpp"
+#include "xercesc/framework/URLInputSource.hpp"
+#include "xercesc/framework/XMLGrammarDescription.hpp"
+#include "xercesc/framework/XMLDTDDescription.hpp"
+#include "xercesc/framework/XMLSchemaDescription.hpp"
+#include "xercesc/util/NameIdPool.hpp"
+#include "xercesc/util/XMLEnumerator.hpp"
+#include "xercesc/framework/XMLValidator.hpp"
+#include "xercesc/validators/common/Grammar.hpp"
+#include "xercesc/validators/DTD/DTDAttDef.hpp"
+#include "xercesc/validators/DTD/DTDAttDefList.hpp"
+#include "xercesc/validators/DTD/DTDGrammar.hpp"
+#include "xercesc/validators/DTD/DTDValidator.hpp"
+#include "xercesc/validators/schema/SchemaGrammar.hpp"
+#include "xercesc/validators/schema/SchemaValidator.hpp"
+#include "xercesc/validators/schema/SchemaAttDefList.hpp"
+#include "xercesc/validators/schema/SchemaAttDef.hpp"
+#include "xercesc/framework/XMLFormatter.hpp"
+#include "xercesc/framework/MemBufFormatTarget.hpp"
+#include "xercesc/framework/LocalFileFormatTarget.hpp"
+#include "xercesc/framework/StdOutFormatTarget.hpp"
+#include "xercesc/framework/psvi/PSVIHandler.hpp"
+
+%}
+
diff --git a/swig/interfaces/parsers.i b/swig/interfaces/parsers.i
index 3a74a236e..321afb1df 100644
--- a/swig/interfaces/parsers.i
+++ b/swig/interfaces/parsers.i
@@ -3,8 +3,8 @@
%include "xercesc/framework/psvi/PSVIHandler.hpp"
// these want to be removed to a separate DOM module
-%include "parsers/AbstractDOMParser.i"
-%include "parsers/XercesDOMParser.i"
+// %include "parsers/AbstractDOMParser.i"
+// %include "parsers/XercesDOMParser.i"
%include "xercesc/sax/Parser.hpp"
%include "xercesc/parsers/SAXParser.hpp"
diff --git a/swig/interfaces/typemaps-general.i b/swig/interfaces/typemaps-general.i
index 53a061005..ea7250d67 100644
--- a/swig/interfaces/typemaps-general.i
+++ b/swig/interfaces/typemaps-general.i
@@ -14,6 +14,9 @@
* limitations under the License.
*/
+// this is new for Xerces-C-3.0
+%apply size_t { ssize_t };
+
/*
* Scripting languages are not going to change the default memory manager
* so we always default this argument
@@ -51,28 +54,6 @@
}
}
-/*
- * Enable conversion of void* => XMLCh* in setProperty()
- *
- * The in typemap converts the void* to an XMLCh*
- *
- * The freearg typemap deletes the transcoded string
- *
- */
-%typemap(in) (void* value) {
- // now check the value
- if ($input == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",$argnum,"$symname");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- $1 = Perl2XMLString($input);
- }
-}
-%typemap(freearg) void * %{
- delete[] $1;
-%}
-
/*
* Dynamic Casts
*
diff --git a/swig/perl/DOM/DOM.pm b/swig/perl/DOM/DOM.pm
new file mode 100644
index 000000000..bead924c6
--- /dev/null
+++ b/swig/perl/DOM/DOM.pm
@@ -0,0 +1,2796 @@
+ #
+ # Copyright 2002,2004 The Apache Software Foundation.
+ #
+ # Licensed under the Apache License, Version 2.0 (the "License");
+ # you may not use this file except in compliance with the License.
+ # You may obtain a copy of the License at
+ #
+ # http://www.apache.org/licenses/LICENSE-2.0
+ #
+ # Unless required by applicable law or agreed to in writing, software
+ # distributed under the License is distributed on an "AS IS" BASIS,
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ # See the License for the specific language governing permissions and
+ # limitations under the License.
+ #
+
+# This file was created automatically by SWIG 1.3.30.
+# Don't modify this file, modify the SWIG interface instead.
+package XML::Xerces::DOM;
+require DynaLoader;
+use base qw(DynaLoader);
+require XML::Xerces;
+package XML::Xercesc;
+bootstrap XML::Xerces::DOM;
+package XML::Xerces;
+package XML::Xerces::DOMNodeList;
+# convert the NodeList to a perl list
+sub to_list {
+ my $self = shift;
+ my @list;
+ for (my $i=0;$i<$self->getLength();$i++) {
+ push(@list,$self->item($i));
+ }
+ return @list;
+}
+
+package XML::Xerces::DOMStringList;
+# convert the StringList to a perl list
+sub to_list {
+ my $self = shift;
+ my @list;
+ for (my $i=0;$i<$self->getLength();$i++) {
+ push(@list,$self->item($i));
+ }
+ return @list;
+}
+
+package XML::Xerces::DOMNamedNodeMap;
+# convert the NamedNodeMap to a perl hash
+sub to_hash {
+ my $self = shift;
+ my @list;
+ for (my $i=0;$i<$self->getLength();$i++) {
+ my $node = $self->item($i);
+ push(@list, $node->to_hash());
+ }
+ return @list;
+}
+
+package XML::Xerces::DOMNode;
+sub to_hash {
+ my $self = shift;
+ return ($self->getNodeName,$self->getNodeValue);
+}
+
+sub quote_content {
+ my ($self,$node_value) = @_;
+
+ $node_value =~ s/&/&/g;
+ $node_value =~ s/</</g;
+ $node_value =~ s/>/>/g;
+ $node_value =~ s/\"/"/g;
+ $node_value =~ s/\'/'/g;
+
+ return $node_value;
+}
+
+package XML::Xerces::DOMEntity;
+sub to_hash {
+ my $self = shift;
+ if ($self->hasChildNodes) {
+ return ($self->getNodeName(),
+ $self->getFirstChild->getNodeValue());
+ } else {
+ return ($self->getNodeName(), '');
+ }
+}
+
+package XML::Xerces::DOMText;
+sub serialize {
+ return $_[0]->quote_content($_[0]->getNodeValue);
+}
+
+package XML::Xerces::DOMProcessingInstruction;
+sub serialize {
+ my $output .= '<?' . $_[0]->getNodeName;
+ if (length(my $str = $_[0]->getNodeValue)) {
+ $output .= " $str";
+ }
+ $output .= '?>';
+ return $output;
+}
+
+package XML::Xerces::DOMDocument;
+sub serialize {
+ my $output;
+ my $indent = 2;
+ for(my $child = $_[0]->getFirstChild() ;
+ defined $child ;
+ $child = $child->getNextSibling())
+ {
+ $output .= $child->serialize($indent);
+ }
+ return "$output\n";
+}
+
+package XML::Xerces::DOMElement;
+sub serialize {
+ my ($self,$indent) = @_;
+ $indent ||= 0;
+ my $output;
+ ELEMENT: {
+ my $node_name = $self->getNodeName;
+ $output .= "<$node_name";
+
+ my $attributes = $self->getAttributes;
+ my $attribute_count = $attributes->getLength;
+
+ for(my $ix = 0 ; $ix < $attribute_count ; ++$ix) {
+ my $attribute = $attributes->item($ix);
+ $output .= ' ' . $attribute->getNodeName . '="' . $self->quote_content($attribute->getNodeValue) . '"';
+ }
+
+ my $child = $self->getFirstChild();
+ if (!defined $child) {
+ $output .= '/>';
+ last ELEMENT;
+ }
+
+ $output .= '>';
+ while (defined $child) {
+ $output .= $child->serialize($indent+2);
+ $child = $child->getNextSibling();
+ }
+ $output .= "</$node_name>";
+ }
+ return $output;
+}
+
+package XML::Xerces::DOMEntityReference;
+sub serialize {
+ my ($self) = @_;
+ my $output;
+ for(my $child = $self->getFirstChild() ;
+ defined $child;
+ $child = $child->getNextSibling())
+ {
+ $output .= $child->serialize();
+ }
+ return $output;
+}
+
+package XML::Xerces::DOMCDATASection;
+sub serialize {
+ return '<![CDATA[' . $_[0]->getNodeValue . ']]>';
+}
+
+package XML::Xerces::DOMComment;
+sub serialize {
+ return '<!--' . $_[0]->getNodeValue . "-->\n";
+}
+
+package XML::Xerces::DOMDocumentType;
+sub serialize {
+ my $output;
+ $output .= '<!DOCTYPE ' . $_[0]->getNodeName;
+
+ my $id;
+ if ($id = $_[0]->getPublicId) {
+ $output .= qq[ PUBLIC "$id"];
+ if ($id = $_[0]->getSystemId) {
+ $output .= qq[ "$id"];
+ }
+ } elsif ($id = $_[0]->getSystemId) {
+ $output .= qq[ SYSTEM "$id"];
+ }
+
+ if ($id = $_[0]->getInternalSubset) {
+ $output .= " [$id]";
+ }
+
+ $output .= ">\n";
+ return $output;
+}
+
+package XML::Xerces::DOMEntity;
+sub serialize {
+ my $output;
+ $output .= '<!ENTITY ' . $_[0]->getNodeName;
+
+ my $id;
+ if ($id = $_[0]->getPublicId) { $output .= qq[ PUBLIC "$id"]; }
+ if ($id = $_[0]->getSystemId) { $output .= qq[ SYSTEM "$id"]; }
+ if ($id = $_[0]->getNotationName) { $output .= qq[ NDATA "$id"]; }
+
+ $output .= '>';
+ return $output;
+}
+
+package XML::Xerces::DOMException;
+sub getMessage {
+ return shift->{msg};
+}
+
+sub getCode {
+ return shift->{code};
+}
+
+# in previous versions we needed to define this method
+# but it is now obsolete
+package XML::Xerces::DOMElement;
+sub get_text {
+ my $self = shift;
+ warn "XML::Xerces::DOMElement::get_text is depricated, use getTextContent instead";
+ return $self->getTextContent(@_);
+}
+
+package XML::Xerces::DOM;
+use XML::Xerces;
+use vars qw($VERSION @EXPORT);
+
+# ------- FUNCTION WRAPPERS --------
+
+package XML::Xerces;
+
+
+############# Class : XML::Xerces::DOMException ##############
+
+package XML::Xerces::DOMException;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_DOMException(@_);
+ bless $self, $pkg if defined($self);
+}
+
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMException($self);
+ delete $OWNER{$self};
+ }
+}
+
+*INDEX_SIZE_ERR = *XML::Xercesc::DOMException_INDEX_SIZE_ERR;
+*DOMSTRING_SIZE_ERR = *XML::Xercesc::DOMException_DOMSTRING_SIZE_ERR;
+*HIERARCHY_REQUEST_ERR = *XML::Xercesc::DOMException_HIERARCHY_REQUEST_ERR;
+*WRONG_DOCUMENT_ERR = *XML::Xercesc::DOMException_WRONG_DOCUMENT_ERR;
+*INVALID_CHARACTER_ERR = *XML::Xercesc::DOMException_INVALID_CHARACTER_ERR;
+*NO_DATA_ALLOWED_ERR = *XML::Xercesc::DOMException_NO_DATA_ALLOWED_ERR;
+*NO_MODIFICATION_ALLOWED_ERR = *XML::Xercesc::DOMException_NO_MODIFICATION_ALLOWED_ERR;
+*NOT_FOUND_ERR = *XML::Xercesc::DOMException_NOT_FOUND_ERR;
+*NOT_SUPPORTED_ERR = *XML::Xercesc::DOMException_NOT_SUPPORTED_ERR;
+*INUSE_ATTRIBUTE_ERR = *XML::Xercesc::DOMException_INUSE_ATTRIBUTE_ERR;
+*INVALID_STATE_ERR = *XML::Xercesc::DOMException_INVALID_STATE_ERR;
+*SYNTAX_ERR = *XML::Xercesc::DOMException_SYNTAX_ERR;
+*INVALID_MODIFICATION_ERR = *XML::Xercesc::DOMException_INVALID_MODIFICATION_ERR;
+*NAMESPACE_ERR = *XML::Xercesc::DOMException_NAMESPACE_ERR;
+*INVALID_ACCESS_ERR = *XML::Xercesc::DOMException_INVALID_ACCESS_ERR;
+*VALIDATION_ERR = *XML::Xercesc::DOMException_VALIDATION_ERR;
+*TYPE_MISMATCH_ERR = *XML::Xercesc::DOMException_TYPE_MISMATCH_ERR;
+*getMessage = *XML::Xercesc::DOMException_getMessage;
+*swig_code_get = *XML::Xercesc::DOMException_code_get;
+*swig_code_set = *XML::Xercesc::DOMException_code_set;
+*swig_msg_get = *XML::Xercesc::DOMException_msg_get;
+*swig_msg_set = *XML::Xercesc::DOMException_msg_set;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMNode ##############
+
+package XML::Xerces::DOMNode;
+use overload
+ "!=" => sub { $_[0]->__ne__($_[1])},
+ "==" => sub { $_[0]->__eq__($_[1])},
+ "fallback" => 1;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMNode($self);
+ delete $OWNER{$self};
+ }
+}
+
+*ELEMENT_NODE = *XML::Xercesc::DOMNode_ELEMENT_NODE;
+*ATTRIBUTE_NODE = *XML::Xercesc::DOMNode_ATTRIBUTE_NODE;
+*TEXT_NODE = *XML::Xercesc::DOMNode_TEXT_NODE;
+*CDATA_SECTION_NODE = *XML::Xercesc::DOMNode_CDATA_SECTION_NODE;
+*ENTITY_REFERENCE_NODE = *XML::Xercesc::DOMNode_ENTITY_REFERENCE_NODE;
+*ENTITY_NODE = *XML::Xercesc::DOMNode_ENTITY_NODE;
+*PROCESSING_INSTRUCTION_NODE = *XML::Xercesc::DOMNode_PROCESSING_INSTRUCTION_NODE;
+*COMMENT_NODE = *XML::Xercesc::DOMNode_COMMENT_NODE;
+*DOCUMENT_NODE = *XML::Xercesc::DOMNode_DOCUMENT_NODE;
+*DOCUMENT_TYPE_NODE = *XML::Xercesc::DOMNode_DOCUMENT_TYPE_NODE;
+*DOCUMENT_FRAGMENT_NODE = *XML::Xercesc::DOMNode_DOCUMENT_FRAGMENT_NODE;
+*NOTATION_NODE = *XML::Xercesc::DOMNode_NOTATION_NODE;
+*DOCUMENT_POSITION_DISCONNECTED = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_DISCONNECTED;
+*DOCUMENT_POSITION_PRECEDING = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_PRECEDING;
+*DOCUMENT_POSITION_FOLLOWING = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_FOLLOWING;
+*DOCUMENT_POSITION_CONTAINS = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_CONTAINS;
+*DOCUMENT_POSITION_CONTAINED_BY = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_CONTAINED_BY;
+*DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
+*getNodeName = *XML::Xercesc::DOMNode_getNodeName;
+*getNodeValue = *XML::Xercesc::DOMNode_getNodeValue;
+*getNodeType = *XML::Xercesc::DOMNode_getNodeType;
+*getParentNode = *XML::Xercesc::DOMNode_getParentNode;
+sub getChildNodes {
+ my $result = XML::Xercesc::DOMNode_getChildNodes (@_);
+ unless (defined$result) {
+ return () if wantarray;
+ return undef;#if *not* wantarray
+ }
+ return $result->to_list() if wantarray;
+ return $result;#if *not* wantarray
+}
+
+*getFirstChild = *XML::Xercesc::DOMNode_getFirstChild;
+*getLastChild = *XML::Xercesc::DOMNode_getLastChild;
+*getPreviousSibling = *XML::Xercesc::DOMNode_getPreviousSibling;
+*getNextSibling = *XML::Xercesc::DOMNode_getNextSibling;
+sub getAttributes {
+ my $result = XML::Xercesc::DOMNode_getAttributes (@_);
+ unless (defined$result) {
+ return () if wantarray;
+ return undef;#if *not* wantarray
+ }
+ return $result->to_hash() if wantarray;
+ return $result;#if *not* wantarray
+}
+
+*getOwnerDocument = *XML::Xercesc::DOMNode_getOwnerDocument;
+*cloneNode = *XML::Xercesc::DOMNode_cloneNode;
+*insertBefore = *XML::Xercesc::DOMNode_insertBefore;
+*replaceChild = *XML::Xercesc::DOMNode_replaceChild;
+*removeChild = *XML::Xercesc::DOMNode_removeChild;
+*appendChild = *XML::Xercesc::DOMNode_appendChild;
+*hasChildNodes = *XML::Xercesc::DOMNode_hasChildNodes;
+*setNodeValue = *XML::Xercesc::DOMNode_setNodeValue;
+*normalize = *XML::Xercesc::DOMNode_normalize;
+*isSupported = *XML::Xercesc::DOMNode_isSupported;
+*getNamespaceURI = *XML::Xercesc::DOMNode_getNamespaceURI;
+*getLocalName = *XML::Xercesc::DOMNode_getLocalName;
+*setPrefix = *XML::Xercesc::DOMNode_setPrefix;
+*hasAttributes = *XML::Xercesc::DOMNode_hasAttributes;
+*isSameNode = *XML::Xercesc::DOMNode_isSameNode;
+*isEqualNode = *XML::Xercesc::DOMNode_isEqualNode;
+*setUserData = *XML::Xercesc::DOMNode_setUserData;
+*getUserData = *XML::Xercesc::DOMNode_getUserData;
+*getBaseURI = *XML::Xercesc::DOMNode_getBaseURI;
+*compareDocumentPosition = *XML::Xercesc::DOMNode_compareDocumentPosition;
+*getTextContent = *XML::Xercesc::DOMNode_getTextContent;
+*setTextContent = *XML::Xercesc::DOMNode_setTextContent;
+*lookupPrefix = *XML::Xercesc::DOMNode_lookupPrefix;
+*isDefaultNamespace = *XML::Xercesc::DOMNode_isDefaultNamespace;
+*lookupNamespaceURI = *XML::Xercesc::DOMNode_lookupNamespaceURI;
+*getFeature = *XML::Xercesc::DOMNode_getFeature;
+*release = *XML::Xercesc::DOMNode_release;
+*__eq__ = *XML::Xercesc::DOMNode___eq__;
+*__ne__ = *XML::Xercesc::DOMNode___ne__;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMAttr ##############
+
+package XML::Xerces::DOMAttr;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMAttr($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getName = *XML::Xercesc::DOMAttr_getName;
+*getSpecified = *XML::Xercesc::DOMAttr_getSpecified;
+*getValue = *XML::Xercesc::DOMAttr_getValue;
+*setValue = *XML::Xercesc::DOMAttr_setValue;
+*getOwnerElement = *XML::Xercesc::DOMAttr_getOwnerElement;
+*isId = *XML::Xercesc::DOMAttr_isId;
+*getSchemaTypeInfo = *XML::Xercesc::DOMAttr_getSchemaTypeInfo;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMElement ##############
+
+package XML::Xerces::DOMElement;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMElement($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getTagName = *XML::Xercesc::DOMElement_getTagName;
+*getAttribute = *XML::Xercesc::DOMElement_getAttribute;
+*getAttributeNode = *XML::Xercesc::DOMElement_getAttributeNode;
+sub getElementsByTagName {
+ my $result = XML::Xercesc::DOMElement_getElementsByTagName (@_);
+ unless (defined$result) {
+ return () if wantarray;
+ return undef;#if *not* wantarray
+ }
+ return $result->to_list() if wantarray;
+ return $result;#if *not* wantarray
+}
+
+*setAttribute = *XML::Xercesc::DOMElement_setAttribute;
+*setAttributeNode = *XML::Xercesc::DOMElement_setAttributeNode;
+*removeAttributeNode = *XML::Xercesc::DOMElement_removeAttributeNode;
+*removeAttribute = *XML::Xercesc::DOMElement_removeAttribute;
+*getAttributeNS = *XML::Xercesc::DOMElement_getAttributeNS;
+*setAttributeNS = *XML::Xercesc::DOMElement_setAttributeNS;
+*removeAttributeNS = *XML::Xercesc::DOMElement_removeAttributeNS;
+*getAttributeNodeNS = *XML::Xercesc::DOMElement_getAttributeNodeNS;
+*setAttributeNodeNS = *XML::Xercesc::DOMElement_setAttributeNodeNS;
+sub getElementsByTagNameNS {
+ my $result = XML::Xercesc::DOMElement_getElementsByTagNameNS (@_);
+ unless (defined$result) {
+ return () if wantarray;
+ return undef;#if *not* wantarray
+ }
+ return $result->to_list() if wantarray;
+ return $result;#if *not* wantarray
+}
+
+*hasAttribute = *XML::Xercesc::DOMElement_hasAttribute;
+*hasAttributeNS = *XML::Xercesc::DOMElement_hasAttributeNS;
+*setIdAttribute = *XML::Xercesc::DOMElement_setIdAttribute;
+*setIdAttributeNS = *XML::Xercesc::DOMElement_setIdAttributeNS;
+*setIdAttributeNode = *XML::Xercesc::DOMElement_setIdAttributeNode;
+*getSchemaTypeInfo = *XML::Xercesc::DOMElement_getSchemaTypeInfo;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMEntity ##############
+
+package XML::Xerces::DOMEntity;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMEntity($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getPublicId = *XML::Xercesc::DOMEntity_getPublicId;
+*getSystemId = *XML::Xercesc::DOMEntity_getSystemId;
+*getNotationName = *XML::Xercesc::DOMEntity_getNotationName;
+*getInputEncoding = *XML::Xercesc::DOMEntity_getInputEncoding;
+*getXmlEncoding = *XML::Xercesc::DOMEntity_getXmlEncoding;
+*getXmlVersion = *XML::Xercesc::DOMEntity_getXmlVersion;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMDocumentType ##############
+
+package XML::Xerces::DOMDocumentType;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMDocumentType($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getName = *XML::Xercesc::DOMDocumentType_getName;
+sub getEntities {
+ my $result = XML::Xercesc::DOMDocumentType_getEntities (@_);
+ unless (defined$result) {
+ return () if wantarray;
+ return undef;#if *not* wantarray
+ }
+ return $result->to_hash() if wantarray;
+ return $result;#if *not* wantarray
+}
+
+sub getNotations {
+ my $result = XML::Xercesc::DOMDocumentType_getNotations (@_);
+ unless (defined$result) {
+ return () if wantarray;
+ return undef;#if *not* wantarray
+ }
+ return $result->to_hash() if wantarray;
+ return $result;#if *not* wantarray
+}
+
+*getPublicId = *XML::Xercesc::DOMDocumentType_getPublicId;
+*getSystemId = *XML::Xercesc::DOMDocumentType_getSystemId;
+*getInternalSubset = *XML::Xercesc::DOMDocumentType_getInternalSubset;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMCharacterData ##############
+
+package XML::Xerces::DOMCharacterData;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMCharacterData($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getData = *XML::Xercesc::DOMCharacterData_getData;
+*getLength = *XML::Xercesc::DOMCharacterData_getLength;
+*substringData = *XML::Xercesc::DOMCharacterData_substringData;
+*appendData = *XML::Xercesc::DOMCharacterData_appendData;
+*insertData = *XML::Xercesc::DOMCharacterData_insertData;
+*deleteData = *XML::Xercesc::DOMCharacterData_deleteData;
+*replaceData = *XML::Xercesc::DOMCharacterData_replaceData;
+*setData = *XML::Xercesc::DOMCharacterData_setData;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMComment ##############
+
+package XML::Xerces::DOMComment;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMCharacterData XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMComment($self);
+ delete $OWNER{$self};
+ }
+}
+
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMText ##############
+
+package XML::Xerces::DOMText;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMCharacterData XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMText($self);
+ delete $OWNER{$self};
+ }
+}
+
+*splitText = *XML::Xercesc::DOMText_splitText;
+*getIsElementContentWhitespace = *XML::Xercesc::DOMText_getIsElementContentWhitespace;
+*getWholeText = *XML::Xercesc::DOMText_getWholeText;
+*replaceWholeText = *XML::Xercesc::DOMText_replaceWholeText;
+*isIgnorableWhitespace = *XML::Xercesc::DOMText_isIgnorableWhitespace;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMCDATASection ##############
+
+package XML::Xerces::DOMCDATASection;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMText XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMCDATASection($self);
+ delete $OWNER{$self};
+ }
+}
+
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMNodeList ##############
+
+package XML::Xerces::DOMNodeList;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMNodeList($self);
+ delete $OWNER{$self};
+ }
+}
+
+*item = *XML::Xercesc::DOMNodeList_item;
+*getLength = *XML::Xercesc::DOMNodeList_getLength;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMNamedNodeMap ##############
+
+package XML::Xerces::DOMNamedNodeMap;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMNamedNodeMap($self);
+ delete $OWNER{$self};
+ }
+}
+
+*setNamedItem = *XML::Xercesc::DOMNamedNodeMap_setNamedItem;
+*item = *XML::Xercesc::DOMNamedNodeMap_item;
+*getNamedItem = *XML::Xercesc::DOMNamedNodeMap_getNamedItem;
+*getLength = *XML::Xercesc::DOMNamedNodeMap_getLength;
+*removeNamedItem = *XML::Xercesc::DOMNamedNodeMap_removeNamedItem;
+*getNamedItemNS = *XML::Xercesc::DOMNamedNodeMap_getNamedItemNS;
+*setNamedItemNS = *XML::Xercesc::DOMNamedNodeMap_setNamedItemNS;
+*removeNamedItemNS = *XML::Xercesc::DOMNamedNodeMap_removeNamedItemNS;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMDocumentFragment ##############
+
+package XML::Xerces::DOMDocumentFragment;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMDocumentFragment($self);
+ delete $OWNER{$self};
+ }
+}
+
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMEntityReference ##############
+
+package XML::Xerces::DOMEntityReference;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMEntityReference($self);
+ delete $OWNER{$self};
+ }
+}
+
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMNotation ##############
+
+package XML::Xerces::DOMNotation;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMNotation($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getPublicId = *XML::Xercesc::DOMNotation_getPublicId;
+*getSystemId = *XML::Xercesc::DOMNotation_getSystemId;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMProcessingInstruction ##############
+
+package XML::Xerces::DOMProcessingInstruction;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMProcessingInstruction($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getTarget = *XML::Xercesc::DOMProcessingInstruction_getTarget;
+*getData = *XML::Xercesc::DOMProcessingInstruction_getData;
+*setData = *XML::Xercesc::DOMProcessingInstruction_setData;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMTypeInfo ##############
+
+package XML::Xerces::DOMTypeInfo;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMTypeInfo($self);
+ delete $OWNER{$self};
+ }
+}
+
+*DERIVATION_RESTRICTION = *XML::Xercesc::DOMTypeInfo_DERIVATION_RESTRICTION;
+*DERIVATION_EXTENSION = *XML::Xercesc::DOMTypeInfo_DERIVATION_EXTENSION;
+*DERIVATION_UNION = *XML::Xercesc::DOMTypeInfo_DERIVATION_UNION;
+*DERIVATION_LIST = *XML::Xercesc::DOMTypeInfo_DERIVATION_LIST;
+*getTypeName = *XML::Xercesc::DOMTypeInfo_getTypeName;
+*getTypeNamespace = *XML::Xercesc::DOMTypeInfo_getTypeNamespace;
+*isDerivedFrom = *XML::Xercesc::DOMTypeInfo_isDerivedFrom;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMPSVITypeInfo ##############
+
+package XML::Xerces::DOMPSVITypeInfo;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+*PSVI_Validity = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Validity;
+*PSVI_Validitation_Attempted = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Validitation_Attempted;
+*PSVI_Type_Definition_Type = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Type_Definition_Type;
+*PSVI_Type_Definition_Name = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Type_Definition_Name;
+*PSVI_Type_Definition_Namespace = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Type_Definition_Namespace;
+*PSVI_Type_Definition_Anonymous = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Type_Definition_Anonymous;
+*PSVI_Nil = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Nil;
+*PSVI_Member_Type_Definition_Name = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Member_Type_Definition_Name;
+*PSVI_Member_Type_Definition_Namespace = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Member_Type_Definition_Namespace;
+*PSVI_Member_Type_Definition_Anonymous = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Member_Type_Definition_Anonymous;
+*PSVI_Schema_Default = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Schema_Default;
+*PSVI_Schema_Normalized_Value = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Schema_Normalized_Value;
+*PSVI_Schema_Specified = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Schema_Specified;
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMPSVITypeInfo($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getStringProperty = *XML::Xercesc::DOMPSVITypeInfo_getStringProperty;
+*getNumericProperty = *XML::Xercesc::DOMPSVITypeInfo_getNumericProperty;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMXPathEvaluator ##############
+
+package XML::Xerces::DOMXPathEvaluator;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMXPathEvaluator($self);
+ delete $OWNER{$self};
+ }
+}
+
+*createExpression = *XML::Xercesc::DOMXPathEvaluator_createExpression;
+*createNSResolver = *XML::Xercesc::DOMXPathEvaluator_createNSResolver;
+*evaluate = *XML::Xercesc::DOMXPathEvaluator_evaluate;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMXPathException ##############
+
+package XML::Xerces::DOMXPathException;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_DOMXPathException(@_);
+ bless $self, $pkg if defined($self);
+}
+
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMXPathException($self);
+ delete $OWNER{$self};
+ }
+}
+
+*INVALID_EXPRESSION_ERR = *XML::Xercesc::DOMXPathException_INVALID_EXPRESSION_ERR;
+*TYPE_ERR = *XML::Xercesc::DOMXPathException_TYPE_ERR;
+*swig_code_get = *XML::Xercesc::DOMXPathException_code_get;
+*swig_code_set = *XML::Xercesc::DOMXPathException_code_set;
+*swig_msg_get = *XML::Xercesc::DOMXPathException_msg_get;
+*swig_msg_set = *XML::Xercesc::DOMXPathException_msg_set;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMXPathExpression ##############
+
+package XML::Xerces::DOMXPathExpression;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMXPathExpression($self);
+ delete $OWNER{$self};
+ }
+}
+
+*evaluate = *XML::Xercesc::DOMXPathExpression_evaluate;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMXPathNamespace ##############
+
+package XML::Xerces::DOMXPathNamespace;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+*XPATH_NAMESPACE_NODE = *XML::Xercesc::DOMXPathNamespace_XPATH_NAMESPACE_NODE;
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMXPathNamespace($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getOwnerElement = *XML::Xercesc::DOMXPathNamespace_getOwnerElement;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMXPathNSResolver ##############
+
+package XML::Xerces::DOMXPathNSResolver;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMXPathNSResolver($self);
+ delete $OWNER{$self};
+ }
+}
+
+*lookupNamespaceURI = *XML::Xercesc::DOMXPathNSResolver_lookupNamespaceURI;
+*lookupPrefix = *XML::Xercesc::DOMXPathNSResolver_lookupPrefix;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMXPathResult ##############
+
+package XML::Xerces::DOMXPathResult;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMXPathResult($self);
+ delete $OWNER{$self};
+ }
+}
+
+*ANY_TYPE = *XML::Xercesc::DOMXPathResult_ANY_TYPE;
+*NUMBER_TYPE = *XML::Xercesc::DOMXPathResult_NUMBER_TYPE;
+*STRING_TYPE = *XML::Xercesc::DOMXPathResult_STRING_TYPE;
+*BOOLEAN_TYPE = *XML::Xercesc::DOMXPathResult_BOOLEAN_TYPE;
+*UNORDERED_NODE_ITERATOR_TYPE = *XML::Xercesc::DOMXPathResult_UNORDERED_NODE_ITERATOR_TYPE;
+*ORDERED_NODE_ITERATOR_TYPE = *XML::Xercesc::DOMXPathResult_ORDERED_NODE_ITERATOR_TYPE;
+*UNORDERED_NODE_SNAPSHOT_TYPE = *XML::Xercesc::DOMXPathResult_UNORDERED_NODE_SNAPSHOT_TYPE;
+*ORDERED_NODE_SNAPSHOT_TYPE = *XML::Xercesc::DOMXPathResult_ORDERED_NODE_SNAPSHOT_TYPE;
+*ANY_UNORDERED_NODE_TYPE = *XML::Xercesc::DOMXPathResult_ANY_UNORDERED_NODE_TYPE;
+*FIRST_ORDERED_NODE_TYPE = *XML::Xercesc::DOMXPathResult_FIRST_ORDERED_NODE_TYPE;
+*getBooleanValue = *XML::Xercesc::DOMXPathResult_getBooleanValue;
+*getInvalidIteratorState = *XML::Xercesc::DOMXPathResult_getInvalidIteratorState;
+*getNumberValue = *XML::Xercesc::DOMXPathResult_getNumberValue;
+*getResultType = *XML::Xercesc::DOMXPathResult_getResultType;
+*getSingleNodeValue = *XML::Xercesc::DOMXPathResult_getSingleNodeValue;
+*getSnapshotLength = *XML::Xercesc::DOMXPathResult_getSnapshotLength;
+*getStringValue = *XML::Xercesc::DOMXPathResult_getStringValue;
+*iterateNext = *XML::Xercesc::DOMXPathResult_iterateNext;
+*snapshotItem = *XML::Xercesc::DOMXPathResult_snapshotItem;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMDocumentRange ##############
+
+package XML::Xerces::DOMDocumentRange;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMDocumentRange($self);
+ delete $OWNER{$self};
+ }
+}
+
+*createRange = *XML::Xercesc::DOMDocumentRange_createRange;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMDocumentTraversal ##############
+
+package XML::Xerces::DOMDocumentTraversal;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMDocumentTraversal($self);
+ delete $OWNER{$self};
+ }
+}
+
+sub createNodeIterator {
+ my ($self,$root,$what,$filter,$expand) = @_;
+ my $callback = XML::Xerces::PerlNodeFilterCallbackHandler->new($filter);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__NODE_FILTER} = $callback;
+
+ my @args = ($self,$root,$what,$callback,$expand);
+ if ($args[0]->isa('XML::Xerces::DOMDocument')) {
+
+ }
+ return XML::Xercesc::DOMDocumentTraversal_createNodeIterator(@args);
+}
+
+sub createTreeWalker {
+ my ($self,$root,$what,$filter,$expand) = @_;
+ my $callback = XML::Xerces::PerlNodeFilterCallbackHandler->new($filter);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__NODE_FILTER} = $callback;
+
+ my @args = ($self,$root,$what,$callback,$expand);
+ if ($args[0]->isa('XML::Xerces::DOMDocument')) {
+
+ }
+ return XML::Xercesc::DOMDocumentTraversal_createTreeWalker(@args);
+}
+
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMNodeIterator ##############
+
+package XML::Xerces::DOMNodeIterator;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMNodeIterator($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getRoot = *XML::Xercesc::DOMNodeIterator_getRoot;
+*getWhatToShow = *XML::Xercesc::DOMNodeIterator_getWhatToShow;
+*getFilter = *XML::Xercesc::DOMNodeIterator_getFilter;
+*getExpandEntityReferences = *XML::Xercesc::DOMNodeIterator_getExpandEntityReferences;
+*nextNode = *XML::Xercesc::DOMNodeIterator_nextNode;
+*previousNode = *XML::Xercesc::DOMNodeIterator_previousNode;
+*detach = *XML::Xercesc::DOMNodeIterator_detach;
+*release = *XML::Xercesc::DOMNodeIterator_release;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMNodeFilter ##############
+
+package XML::Xerces::DOMNodeFilter;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMNodeFilter($self);
+ delete $OWNER{$self};
+ }
+}
+
+*FILTER_ACCEPT = *XML::Xercesc::DOMNodeFilter_FILTER_ACCEPT;
+*FILTER_REJECT = *XML::Xercesc::DOMNodeFilter_FILTER_REJECT;
+*FILTER_SKIP = *XML::Xercesc::DOMNodeFilter_FILTER_SKIP;
+*SHOW_ALL = *XML::Xercesc::DOMNodeFilter_SHOW_ALL;
+*SHOW_ELEMENT = *XML::Xercesc::DOMNodeFilter_SHOW_ELEMENT;
+*SHOW_ATTRIBUTE = *XML::Xercesc::DOMNodeFilter_SHOW_ATTRIBUTE;
+*SHOW_TEXT = *XML::Xercesc::DOMNodeFilter_SHOW_TEXT;
+*SHOW_CDATA_SECTION = *XML::Xercesc::DOMNodeFilter_SHOW_CDATA_SECTION;
+*SHOW_ENTITY_REFERENCE = *XML::Xercesc::DOMNodeFilter_SHOW_ENTITY_REFERENCE;
+*SHOW_ENTITY = *XML::Xercesc::DOMNodeFilter_SHOW_ENTITY;
+*SHOW_PROCESSING_INSTRUCTION = *XML::Xercesc::DOMNodeFilter_SHOW_PROCESSING_INSTRUCTION;
+*SHOW_COMMENT = *XML::Xercesc::DOMNodeFilter_SHOW_COMMENT;
+*SHOW_DOCUMENT = *XML::Xercesc::DOMNodeFilter_SHOW_DOCUMENT;
+*SHOW_DOCUMENT_TYPE = *XML::Xercesc::DOMNodeFilter_SHOW_DOCUMENT_TYPE;
+*SHOW_DOCUMENT_FRAGMENT = *XML::Xercesc::DOMNodeFilter_SHOW_DOCUMENT_FRAGMENT;
+*SHOW_NOTATION = *XML::Xercesc::DOMNodeFilter_SHOW_NOTATION;
+*acceptNode = *XML::Xercesc::DOMNodeFilter_acceptNode;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMRange ##############
+
+package XML::Xerces::DOMRange;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMRange($self);
+ delete $OWNER{$self};
+ }
+}
+
+*START_TO_START = *XML::Xercesc::DOMRange_START_TO_START;
+*START_TO_END = *XML::Xercesc::DOMRange_START_TO_END;
+*END_TO_END = *XML::Xercesc::DOMRange_END_TO_END;
+*END_TO_START = *XML::Xercesc::DOMRange_END_TO_START;
+*getStartContainer = *XML::Xercesc::DOMRange_getStartContainer;
+*getStartOffset = *XML::Xercesc::DOMRange_getStartOffset;
+*getEndContainer = *XML::Xercesc::DOMRange_getEndContainer;
+*getEndOffset = *XML::Xercesc::DOMRange_getEndOffset;
+*getCollapsed = *XML::Xercesc::DOMRange_getCollapsed;
+*getCommonAncestorContainer = *XML::Xercesc::DOMRange_getCommonAncestorContainer;
+*setStart = *XML::Xercesc::DOMRange_setStart;
+*setEnd = *XML::Xercesc::DOMRange_setEnd;
+*setStartBefore = *XML::Xercesc::DOMRange_setStartBefore;
+*setStartAfter = *XML::Xercesc::DOMRange_setStartAfter;
+*setEndBefore = *XML::Xercesc::DOMRange_setEndBefore;
+*setEndAfter = *XML::Xercesc::DOMRange_setEndAfter;
+*collapse = *XML::Xercesc::DOMRange_collapse;
+*selectNode = *XML::Xercesc::DOMRange_selectNode;
+*selectNodeContents = *XML::Xercesc::DOMRange_selectNodeContents;
+*compareBoundaryPoints = *XML::Xercesc::DOMRange_compareBoundaryPoints;
+*deleteContents = *XML::Xercesc::DOMRange_deleteContents;
+*extractContents = *XML::Xercesc::DOMRange_extractContents;
+*cloneContents = *XML::Xercesc::DOMRange_cloneContents;
+*insertNode = *XML::Xercesc::DOMRange_insertNode;
+*surroundContents = *XML::Xercesc::DOMRange_surroundContents;
+*cloneRange = *XML::Xercesc::DOMRange_cloneRange;
+*toString = *XML::Xercesc::DOMRange_toString;
+*detach = *XML::Xercesc::DOMRange_detach;
+*release = *XML::Xercesc::DOMRange_release;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMRangeException ##############
+
+package XML::Xerces::DOMRangeException;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMException XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+*BAD_BOUNDARYPOINTS_ERR = *XML::Xercesc::DOMRangeException_BAD_BOUNDARYPOINTS_ERR;
+*INVALID_NODE_TYPE_ERR = *XML::Xercesc::DOMRangeException_INVALID_NODE_TYPE_ERR;
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_DOMRangeException(@_);
+ bless $self, $pkg if defined($self);
+}
+
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMRangeException($self);
+ delete $OWNER{$self};
+ }
+}
+
+*swig_code_get = *XML::Xercesc::DOMRangeException_code_get;
+*swig_code_set = *XML::Xercesc::DOMRangeException_code_set;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMTreeWalker ##############
+
+package XML::Xerces::DOMTreeWalker;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMTreeWalker($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getRoot = *XML::Xercesc::DOMTreeWalker_getRoot;
+*getWhatToShow = *XML::Xercesc::DOMTreeWalker_getWhatToShow;
+*getFilter = *XML::Xercesc::DOMTreeWalker_getFilter;
+*getExpandEntityReferences = *XML::Xercesc::DOMTreeWalker_getExpandEntityReferences;
+*getCurrentNode = *XML::Xercesc::DOMTreeWalker_getCurrentNode;
+*parentNode = *XML::Xercesc::DOMTreeWalker_parentNode;
+*firstChild = *XML::Xercesc::DOMTreeWalker_firstChild;
+*lastChild = *XML::Xercesc::DOMTreeWalker_lastChild;
+*previousSibling = *XML::Xercesc::DOMTreeWalker_previousSibling;
+*nextSibling = *XML::Xercesc::DOMTreeWalker_nextSibling;
+*previousNode = *XML::Xercesc::DOMTreeWalker_previousNode;
+*nextNode = *XML::Xercesc::DOMTreeWalker_nextNode;
+*setCurrentNode = *XML::Xercesc::DOMTreeWalker_setCurrentNode;
+*release = *XML::Xercesc::DOMTreeWalker_release;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMUserDataHandler ##############
+
+package XML::Xerces::DOMUserDataHandler;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMUserDataHandler($self);
+ delete $OWNER{$self};
+ }
+}
+
+*NODE_CLONED = *XML::Xercesc::DOMUserDataHandler_NODE_CLONED;
+*NODE_IMPORTED = *XML::Xercesc::DOMUserDataHandler_NODE_IMPORTED;
+*NODE_DELETED = *XML::Xercesc::DOMUserDataHandler_NODE_DELETED;
+*NODE_RENAMED = *XML::Xercesc::DOMUserDataHandler_NODE_RENAMED;
+*NODE_ADOPTED = *XML::Xercesc::DOMUserDataHandler_NODE_ADOPTED;
+*handle = *XML::Xercesc::DOMUserDataHandler_handle;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMConfiguration ##############
+
+package XML::Xerces::DOMConfiguration;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub setParameter {
+ my ($self,$name,$value) = @_;
+
+ if ($name eq $XML::Xerces::XMLUni::fgDOMErrorHandler) {
+ $value = XML::Xerces::PerlErrorCallbackHandler->new($_[2]);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__ERROR_HANDLER} = $value;
+ } elsif ($name eq $XML::Xerces::XMLUni::fgXercesEntityResolver) {
+ $value = XML::Xerces::PerlEntityResolverHandler->new($_[2]);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__ENTITY_RESOLVER} = $value;
+ }
+ return XML::Xercesc::DOMConfiguration_setParameter($self,$name,$value);
+}
+
+*getParameter = *XML::Xercesc::DOMConfiguration_getParameter;
+*canSetParameter = *XML::Xercesc::DOMConfiguration_canSetParameter;
+*getParameterNames = *XML::Xercesc::DOMConfiguration_getParameterNames;
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMConfiguration($self);
+ delete $OWNER{$self};
+ }
+}
+
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMStringList ##############
+
+package XML::Xerces::DOMStringList;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMStringList($self);
+ delete $OWNER{$self};
+ }
+}
+
+*item = *XML::Xercesc::DOMStringList_item;
+*getLength = *XML::Xercesc::DOMStringList_getLength;
+*contains = *XML::Xercesc::DOMStringList_contains;
+*release = *XML::Xercesc::DOMStringList_release;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMImplementationLS ##############
+
+package XML::Xerces::DOMImplementationLS;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMImplementationLS($self);
+ delete $OWNER{$self};
+ }
+}
+
+*MODE_SYNCHRONOUS = *XML::Xercesc::DOMImplementationLS_MODE_SYNCHRONOUS;
+*MODE_ASYNCHRONOUS = *XML::Xercesc::DOMImplementationLS_MODE_ASYNCHRONOUS;
+*createLSParser = *XML::Xercesc::DOMImplementationLS_createLSParser;
+*createLSSerializer = *XML::Xercesc::DOMImplementationLS_createLSSerializer;
+*createLSInput = *XML::Xercesc::DOMImplementationLS_createLSInput;
+*createLSOutput = *XML::Xercesc::DOMImplementationLS_createLSOutput;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMImplementation ##############
+
+package XML::Xerces::DOMImplementation;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMImplementationLS XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMImplementation($self);
+ delete $OWNER{$self};
+ }
+}
+
+*hasFeature = *XML::Xercesc::DOMImplementation_hasFeature;
+*createDocumentType = *XML::Xercesc::DOMImplementation_createDocumentType;
+*getFeature = *XML::Xercesc::DOMImplementation_getFeature;
+sub createDocument {
+ if (UNIVERSAL::isa($_[3],"XML::Xerces::DOMDocumentType")) {
+ $_[3]->DISOWN();
+ }
+
+ my $return = XML::Xercesc::DOMImplementation_createDocument(@_);
+
+ return $return;
+}
+
+*getImplementation = *XML::Xercesc::DOMImplementation_getImplementation;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMImplementationList ##############
+
+package XML::Xerces::DOMImplementationList;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMImplementationList($self);
+ delete $OWNER{$self};
+ }
+}
+
+*item = *XML::Xercesc::DOMImplementationList_item;
+*getLength = *XML::Xercesc::DOMImplementationList_getLength;
+*release = *XML::Xercesc::DOMImplementationList_release;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMImplementationSource ##############
+
+package XML::Xerces::DOMImplementationSource;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMImplementationSource($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getDOMImplementation = *XML::Xercesc::DOMImplementationSource_getDOMImplementation;
+*getDOMImplementationList = *XML::Xercesc::DOMImplementationSource_getDOMImplementationList;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMImplementationRegistry ##############
+
+package XML::Xerces::DOMImplementationRegistry;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+*getDOMImplementation = *XML::Xercesc::DOMImplementationRegistry_getDOMImplementation;
+*getDOMImplementationList = *XML::Xercesc::DOMImplementationRegistry_getDOMImplementationList;
+*addSource = *XML::Xercesc::DOMImplementationRegistry_addSource;
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMImplementationRegistry($self);
+ delete $OWNER{$self};
+ }
+}
+
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMError ##############
+
+package XML::Xerces::DOMError;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMError($self);
+ delete $OWNER{$self};
+ }
+}
+
+*DOM_SEVERITY_WARNING = *XML::Xercesc::DOMError_DOM_SEVERITY_WARNING;
+*DOM_SEVERITY_ERROR = *XML::Xercesc::DOMError_DOM_SEVERITY_ERROR;
+*DOM_SEVERITY_FATAL_ERROR = *XML::Xercesc::DOMError_DOM_SEVERITY_FATAL_ERROR;
+*getSeverity = *XML::Xercesc::DOMError_getSeverity;
+*getMessage = *XML::Xercesc::DOMError_getMessage;
+*getLocation = *XML::Xercesc::DOMError_getLocation;
+*getRelatedException = *XML::Xercesc::DOMError_getRelatedException;
+*getType = *XML::Xercesc::DOMError_getType;
+*getRelatedData = *XML::Xercesc::DOMError_getRelatedData;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMErrorHandler ##############
+
+package XML::Xerces::DOMErrorHandler;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMErrorHandler($self);
+ delete $OWNER{$self};
+ }
+}
+
+*handleError = *XML::Xercesc::DOMErrorHandler_handleError;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMDocument ##############
+
+package XML::Xerces::DOMDocument;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMDocumentRange XML::Xerces::DOMXPathEvaluator XML::Xerces::DOMDocumentTraversal XML::Xerces::DOMNode XML::Xerces );
+%OWNER = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+
+ if ($self->can('cleanup')) {
+ $_[0]->cleanup();
+ }
+
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMDocument($self);
+ delete $OWNER{$self};
+ }
+}
+
+*createElement = *XML::Xercesc::DOMDocument_createElement;
+*createDocumentFragment = *XML::Xercesc::DOMDocument_createDocumentFragment;
+*createTextNode = *XML::Xercesc::DOMDocument_createTextNode;
+*createComment = *XML::Xercesc::DOMDocument_createComment;
+*createCDATASection = *XML::Xercesc::DOMDocument_createCDATASection;
+*createProcessingInstruction = *XML::Xercesc::DOMDocument_createProcessingInstruction;
+*createAttribute = *XML::Xercesc::DOMDocument_createAttribute;
+*createEntityReference = *XML::Xercesc::DOMDocument_createEntityReference;
+*getDoctype = *XML::Xercesc::DOMDocument_getDoctype;
+*getImplementation = *XML::Xercesc::DOMDocument_getImplementation;
+*getDocumentElement = *XML::Xercesc::DOMDocument_getDocumentElement;
+sub getElementsByTagName {
+ my $result = XML::Xercesc::DOMDocument_getElementsByTagName (@_);
+ unless (defined$result) {
+ return () if wantarray;
+ return undef;#if *not* wantarray
+ }
+ return $result->to_list() if wantarray;
+ return $result;#if *not* wantarray
+}
+
+*importNode = *XML::Xercesc::DOMDocument_importNode;
+*createAttributeNS = *XML::Xercesc::DOMDocument_createAttributeNS;
+sub getElementsByTagNameNS {
+ my $result = XML::Xercesc::DOMDocument_getElementsByTagNameNS (@_);
+ unless (defined$result) {
+ return () if wantarray;
+ return undef;#if *not* wantarray
+ }
+ return $result->to_list() if wantarray;
+ return $result;#if *not* wantarray
+}
+
+*getElementById = *XML::Xercesc::DOMDocument_getElementById;
+*getInputEncoding = *XML::Xercesc::DOMDocument_getInputEncoding;
+*getXmlEncoding = *XML::Xercesc::DOMDocument_getXmlEncoding;
+*getXmlStandalone = *XML::Xercesc::DOMDocument_getXmlStandalone;
+*setXmlStandalone = *XML::Xercesc::DOMDocument_setXmlStandalone;
+*getXmlVersion = *XML::Xercesc::DOMDocument_getXmlVersion;
+*setXmlVersion = *XML::Xercesc::DOMDocument_setXmlVersion;
+*getDocumentURI = *XML::Xercesc::DOMDocument_getDocumentURI;
+*setDocumentURI = *XML::Xercesc::DOMDocument_setDocumentURI;
+*getStrictErrorChecking = *XML::Xercesc::DOMDocument_getStrictErrorChecking;
+*setStrictErrorChecking = *XML::Xercesc::DOMDocument_setStrictErrorChecking;
+*renameNode = *XML::Xercesc::DOMDocument_renameNode;
+*adoptNode = *XML::Xercesc::DOMDocument_adoptNode;
+*normalizeDocument = *XML::Xercesc::DOMDocument_normalizeDocument;
+*getDOMConfig = *XML::Xercesc::DOMDocument_getDOMConfig;
+*createEntity = *XML::Xercesc::DOMDocument_createEntity;
+*createDocumentType = *XML::Xercesc::DOMDocument_createDocumentType;
+*createNotation = *XML::Xercesc::DOMDocument_createNotation;
+*createElementNS = *XML::Xercesc::DOMDocument_createElementNS;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMLocator ##############
+
+package XML::Xerces::DOMLocator;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMLocator($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getLineNumber = *XML::Xercesc::DOMLocator_getLineNumber;
+*getColumnNumber = *XML::Xercesc::DOMLocator_getColumnNumber;
+*getByteOffset = *XML::Xercesc::DOMLocator_getByteOffset;
+*getUtf16Offset = *XML::Xercesc::DOMLocator_getUtf16Offset;
+*getRelatedNode = *XML::Xercesc::DOMLocator_getRelatedNode;
+*getURI = *XML::Xercesc::DOMLocator_getURI;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMLSResourceResolver ##############
+
+package XML::Xerces::DOMLSResourceResolver;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMLSResourceResolver($self);
+ delete $OWNER{$self};
+ }
+}
+
+*resolveResource = *XML::Xercesc::DOMLSResourceResolver_resolveResource;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMLSInput ##############
+
+package XML::Xerces::DOMLSInput;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMLSInput($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getStringData = *XML::Xercesc::DOMLSInput_getStringData;
+*getByteStream = *XML::Xercesc::DOMLSInput_getByteStream;
+*getEncoding = *XML::Xercesc::DOMLSInput_getEncoding;
+*getPublicId = *XML::Xercesc::DOMLSInput_getPublicId;
+*getSystemId = *XML::Xercesc::DOMLSInput_getSystemId;
+*getBaseURI = *XML::Xercesc::DOMLSInput_getBaseURI;
+*setStringData = *XML::Xercesc::DOMLSInput_setStringData;
+*setByteStream = *XML::Xercesc::DOMLSInput_setByteStream;
+*setEncoding = *XML::Xercesc::DOMLSInput_setEncoding;
+*setPublicId = *XML::Xercesc::DOMLSInput_setPublicId;
+*setSystemId = *XML::Xercesc::DOMLSInput_setSystemId;
+*setBaseURI = *XML::Xercesc::DOMLSInput_setBaseURI;
+*setIssueFatalErrorIfNotFound = *XML::Xercesc::DOMLSInput_setIssueFatalErrorIfNotFound;
+*getIssueFatalErrorIfNotFound = *XML::Xercesc::DOMLSInput_getIssueFatalErrorIfNotFound;
+*release = *XML::Xercesc::DOMLSInput_release;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::Wrapper4InputSource ##############
+
+package XML::Xerces::Wrapper4InputSource;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMLSInput XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ # we never handle the memory
+ # so we tell Perl to forget about the InputSource
+ $_[0]->DISOWN();
+
+ my $self = XML::Xercesc::new_Wrapper4InputSource(@_);
+
+ bless $self, $pkg if defined($self);
+}
+
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_Wrapper4InputSource($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getStringData = *XML::Xercesc::Wrapper4InputSource_getStringData;
+*getByteStream = *XML::Xercesc::Wrapper4InputSource_getByteStream;
+*getEncoding = *XML::Xercesc::Wrapper4InputSource_getEncoding;
+*getPublicId = *XML::Xercesc::Wrapper4InputSource_getPublicId;
+*getSystemId = *XML::Xercesc::Wrapper4InputSource_getSystemId;
+*getBaseURI = *XML::Xercesc::Wrapper4InputSource_getBaseURI;
+*getIssueFatalErrorIfNotFound = *XML::Xercesc::Wrapper4InputSource_getIssueFatalErrorIfNotFound;
+*setStringData = *XML::Xercesc::Wrapper4InputSource_setStringData;
+*setByteStream = *XML::Xercesc::Wrapper4InputSource_setByteStream;
+*setEncoding = *XML::Xercesc::Wrapper4InputSource_setEncoding;
+*setPublicId = *XML::Xercesc::Wrapper4InputSource_setPublicId;
+*setSystemId = *XML::Xercesc::Wrapper4InputSource_setSystemId;
+*setBaseURI = *XML::Xercesc::Wrapper4InputSource_setBaseURI;
+*setIssueFatalErrorIfNotFound = *XML::Xercesc::Wrapper4InputSource_setIssueFatalErrorIfNotFound;
+*release = *XML::Xercesc::Wrapper4InputSource_release;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::Wrapper4DOMLSInput ##############
+
+package XML::Xerces::Wrapper4DOMLSInput;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::InputSource XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_Wrapper4DOMLSInput(@_);
+ bless $self, $pkg if defined($self);
+}
+
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_Wrapper4DOMLSInput($self);
+ delete $OWNER{$self};
+ }
+}
+
+*makeStream = *XML::Xercesc::Wrapper4DOMLSInput_makeStream;
+*getEncoding = *XML::Xercesc::Wrapper4DOMLSInput_getEncoding;
+*getPublicId = *XML::Xercesc::Wrapper4DOMLSInput_getPublicId;
+*getSystemId = *XML::Xercesc::Wrapper4DOMLSInput_getSystemId;
+*getIssueFatalErrorIfNotFound = *XML::Xercesc::Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound;
+*setEncoding = *XML::Xercesc::Wrapper4DOMLSInput_setEncoding;
+*setPublicId = *XML::Xercesc::Wrapper4DOMLSInput_setPublicId;
+*setSystemId = *XML::Xercesc::Wrapper4DOMLSInput_setSystemId;
+*setIssueFatalErrorIfNotFound = *XML::Xercesc::Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMLSParser ##############
+
+package XML::Xerces::DOMLSParser;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMLSParser($self);
+ delete $OWNER{$self};
+ }
+}
+
+*ACTION_APPEND_AS_CHILDREN = *XML::Xercesc::DOMLSParser_ACTION_APPEND_AS_CHILDREN;
+*ACTION_REPLACE_CHILDREN = *XML::Xercesc::DOMLSParser_ACTION_REPLACE_CHILDREN;
+*ACTION_INSERT_BEFORE = *XML::Xercesc::DOMLSParser_ACTION_INSERT_BEFORE;
+*ACTION_INSERT_AFTER = *XML::Xercesc::DOMLSParser_ACTION_INSERT_AFTER;
+*ACTION_REPLACE = *XML::Xercesc::DOMLSParser_ACTION_REPLACE;
+*getDomConfig = *XML::Xercesc::DOMLSParser_getDomConfig;
+*getAsync = *XML::Xercesc::DOMLSParser_getAsync;
+*getBusy = *XML::Xercesc::DOMLSParser_getBusy;
+*setFilter = *XML::Xercesc::DOMLSParser_setFilter;
+*parse = *XML::Xercesc::DOMLSParser_parse;
+*parseURI = *XML::Xercesc::DOMLSParser_parseURI;
+*parseWithContext = *XML::Xercesc::DOMLSParser_parseWithContext;
+*abort = *XML::Xercesc::DOMLSParser_abort;
+*release = *XML::Xercesc::DOMLSParser_release;
+*resetDocumentPool = *XML::Xercesc::DOMLSParser_resetDocumentPool;
+*loadGrammar = *XML::Xercesc::DOMLSParser_loadGrammar;
+*getGrammar = *XML::Xercesc::DOMLSParser_getGrammar;
+*getRootGrammar = *XML::Xercesc::DOMLSParser_getRootGrammar;
+*getURIText = *XML::Xercesc::DOMLSParser_getURIText;
+*resetCachedGrammarPool = *XML::Xercesc::DOMLSParser_resetCachedGrammarPool;
+*getSrcOffset = *XML::Xercesc::DOMLSParser_getSrcOffset;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMLSOutput ##############
+
+package XML::Xerces::DOMLSOutput;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMLSOutput($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getByteStream = *XML::Xercesc::DOMLSOutput_getByteStream;
+*getEncoding = *XML::Xercesc::DOMLSOutput_getEncoding;
+*getSystemId = *XML::Xercesc::DOMLSOutput_getSystemId;
+*setByteStream = *XML::Xercesc::DOMLSOutput_setByteStream;
+*setEncoding = *XML::Xercesc::DOMLSOutput_setEncoding;
+*setSystemId = *XML::Xercesc::DOMLSOutput_setSystemId;
+*release = *XML::Xercesc::DOMLSOutput_release;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::StdOutFormatTarget ##############
+
+package XML::Xerces::StdOutFormatTarget;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_StdOutFormatTarget(@_);
+ bless $self, $pkg if defined($self);
+}
+
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_StdOutFormatTarget($self);
+ delete $OWNER{$self};
+ }
+}
+
+*writeChars = *XML::Xercesc::StdOutFormatTarget_writeChars;
+*flush = *XML::Xercesc::StdOutFormatTarget_flush;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::LocalFileFormatTarget ##############
+
+package XML::Xerces::LocalFileFormatTarget;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_LocalFileFormatTarget(@_);
+ bless $self, $pkg if defined($self);
+}
+
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_LocalFileFormatTarget($self);
+ delete $OWNER{$self};
+ }
+}
+
+*writeChars = *XML::Xercesc::LocalFileFormatTarget_writeChars;
+*flush = *XML::Xercesc::LocalFileFormatTarget_flush;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::MemBufFormatTarget ##############
+
+package XML::Xerces::MemBufFormatTarget;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_MemBufFormatTarget(@_);
+ bless $self, $pkg if defined($self);
+}
+
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_MemBufFormatTarget($self);
+ delete $OWNER{$self};
+ }
+}
+
+*writeChars = *XML::Xercesc::MemBufFormatTarget_writeChars;
+*getRawBuffer = *XML::Xercesc::MemBufFormatTarget_getRawBuffer;
+*getLen = *XML::Xercesc::MemBufFormatTarget_getLen;
+*reset = *XML::Xercesc::MemBufFormatTarget_reset;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMLSException ##############
+
+package XML::Xerces::DOMLSException;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMException XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+*PARSE_ERR = *XML::Xercesc::DOMLSException_PARSE_ERR;
+*SERIALIZE_ERR = *XML::Xercesc::DOMLSException_SERIALIZE_ERR;
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_DOMLSException(@_);
+ bless $self, $pkg if defined($self);
+}
+
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMLSException($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getMessage = *XML::Xercesc::DOMLSException_getMessage;
+*swig_code_get = *XML::Xercesc::DOMLSException_code_get;
+*swig_code_set = *XML::Xercesc::DOMLSException_code_set;
+*swig_msg_get = *XML::Xercesc::DOMLSException_msg_get;
+*swig_msg_set = *XML::Xercesc::DOMLSException_msg_set;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMLSSerializer ##############
+
+package XML::Xerces::DOMLSSerializer;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMLSSerializer($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getDomConfig = *XML::Xercesc::DOMLSSerializer_getDomConfig;
+*setNewLine = *XML::Xercesc::DOMLSSerializer_setNewLine;
+*setFilter = *XML::Xercesc::DOMLSSerializer_setFilter;
+*getNewLine = *XML::Xercesc::DOMLSSerializer_getNewLine;
+*write = *XML::Xercesc::DOMLSSerializer_write;
+*writeToURI = *XML::Xercesc::DOMLSSerializer_writeToURI;
+*writeToString = *XML::Xercesc::DOMLSSerializer_writeToString;
+*release = *XML::Xercesc::DOMLSSerializer_release;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::DOMLSSerializerFilter ##############
+
+package XML::Xerces::DOMLSSerializerFilter;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNodeFilter XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_DOMLSSerializerFilter($self);
+ delete $OWNER{$self};
+ }
+}
+
+*acceptNode = *XML::Xercesc::DOMLSSerializerFilter_acceptNode;
+*getWhatToShow = *XML::Xercesc::DOMLSSerializerFilter_getWhatToShow;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::AbstractDOMParser ##############
+
+package XML::Xerces::AbstractDOMParser;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::PSVIHandler XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+*Val_Never = *XML::Xercesc::AbstractDOMParser_Val_Never;
+*Val_Always = *XML::Xercesc::AbstractDOMParser_Val_Always;
+*Val_Auto = *XML::Xercesc::AbstractDOMParser_Val_Auto;
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_AbstractDOMParser($self);
+ delete $OWNER{$self};
+ }
+}
+
+*reset = *XML::Xercesc::AbstractDOMParser_reset;
+*adoptDocument = *XML::Xercesc::AbstractDOMParser_adoptDocument;
+# hold a reference to the parser internally, so that the
+# document can exist after the parser has gone out of scope
+sub getDocument {
+ my ($self) = @_;
+ my $result = XML::Xercesc::AbstractDOMParser_getDocument($self);
+
+ # the DOMDocument destructor will automatically delete this entry if we
+ # store it using the underlying tied() object
+ $XML::Xerces::REMEMBER{tied(% {$result})}->{__PARSER} = $self;
+ return $result;
+}
+
+*getValidator = *XML::Xercesc::AbstractDOMParser_getValidator;
+*getValidationScheme = *XML::Xercesc::AbstractDOMParser_getValidationScheme;
+*getDoSchema = *XML::Xercesc::AbstractDOMParser_getDoSchema;
+*getValidationSchemaFullChecking = *XML::Xercesc::AbstractDOMParser_getValidationSchemaFullChecking;
+*getIdentityConstraintChecking = *XML::Xercesc::AbstractDOMParser_getIdentityConstraintChecking;
+*getErrorCount = *XML::Xercesc::AbstractDOMParser_getErrorCount;
+*getDoNamespaces = *XML::Xercesc::AbstractDOMParser_getDoNamespaces;
+*getExitOnFirstFatalError = *XML::Xercesc::AbstractDOMParser_getExitOnFirstFatalError;
+*getValidationConstraintFatal = *XML::Xercesc::AbstractDOMParser_getValidationConstraintFatal;
+*getCreateEntityReferenceNodes = *XML::Xercesc::AbstractDOMParser_getCreateEntityReferenceNodes;
+*getIncludeIgnorableWhitespace = *XML::Xercesc::AbstractDOMParser_getIncludeIgnorableWhitespace;
+*getExternalSchemaLocation = *XML::Xercesc::AbstractDOMParser_getExternalSchemaLocation;
+*getExternalNoNamespaceSchemaLocation = *XML::Xercesc::AbstractDOMParser_getExternalNoNamespaceSchemaLocation;
+*getSecurityManager = *XML::Xercesc::AbstractDOMParser_getSecurityManager;
+*getLoadExternalDTD = *XML::Xercesc::AbstractDOMParser_getLoadExternalDTD;
+*getCreateCommentNodes = *XML::Xercesc::AbstractDOMParser_getCreateCommentNodes;
+*getCalculateSrcOfs = *XML::Xercesc::AbstractDOMParser_getCalculateSrcOfs;
+*getStandardUriConformant = *XML::Xercesc::AbstractDOMParser_getStandardUriConformant;
+*getPSVIHandler = *XML::Xercesc::AbstractDOMParser_getPSVIHandler;
+*getCreateSchemaInfo = *XML::Xercesc::AbstractDOMParser_getCreateSchemaInfo;
+*getGenerateSyntheticAnnotations = *XML::Xercesc::AbstractDOMParser_getGenerateSyntheticAnnotations;
+*getValidateAnnotations = *XML::Xercesc::AbstractDOMParser_getValidateAnnotations;
+*getIgnoreAnnotations = *XML::Xercesc::AbstractDOMParser_getIgnoreAnnotations;
+*getDisableDefaultEntityResolution = *XML::Xercesc::AbstractDOMParser_getDisableDefaultEntityResolution;
+*getSkipDTDValidation = *XML::Xercesc::AbstractDOMParser_getSkipDTDValidation;
+*setGenerateSyntheticAnnotations = *XML::Xercesc::AbstractDOMParser_setGenerateSyntheticAnnotations;
+*setValidateAnnotations = *XML::Xercesc::AbstractDOMParser_setValidateAnnotations;
+*setDoNamespaces = *XML::Xercesc::AbstractDOMParser_setDoNamespaces;
+*setExitOnFirstFatalError = *XML::Xercesc::AbstractDOMParser_setExitOnFirstFatalError;
+*setValidationConstraintFatal = *XML::Xercesc::AbstractDOMParser_setValidationConstraintFatal;
+*setCreateEntityReferenceNodes = *XML::Xercesc::AbstractDOMParser_setCreateEntityReferenceNodes;
+*setIncludeIgnorableWhitespace = *XML::Xercesc::AbstractDOMParser_setIncludeIgnorableWhitespace;
+*setValidationScheme = *XML::Xercesc::AbstractDOMParser_setValidationScheme;
+*setDoSchema = *XML::Xercesc::AbstractDOMParser_setDoSchema;
+*setValidationSchemaFullChecking = *XML::Xercesc::AbstractDOMParser_setValidationSchemaFullChecking;
+*setIdentityConstraintChecking = *XML::Xercesc::AbstractDOMParser_setIdentityConstraintChecking;
+*setExternalSchemaLocation = *XML::Xercesc::AbstractDOMParser_setExternalSchemaLocation;
+*setExternalNoNamespaceSchemaLocation = *XML::Xercesc::AbstractDOMParser_setExternalNoNamespaceSchemaLocation;
+*setSecurityManager = *XML::Xercesc::AbstractDOMParser_setSecurityManager;
+*setLoadExternalDTD = *XML::Xercesc::AbstractDOMParser_setLoadExternalDTD;
+*setCreateCommentNodes = *XML::Xercesc::AbstractDOMParser_setCreateCommentNodes;
+*setCalculateSrcOfs = *XML::Xercesc::AbstractDOMParser_setCalculateSrcOfs;
+*setStandardUriConformant = *XML::Xercesc::AbstractDOMParser_setStandardUriConformant;
+*useScanner = *XML::Xercesc::AbstractDOMParser_useScanner;
+*useImplementation = *XML::Xercesc::AbstractDOMParser_useImplementation;
+*setPSVIHandler = *XML::Xercesc::AbstractDOMParser_setPSVIHandler;
+*setCreateSchemaInfo = *XML::Xercesc::AbstractDOMParser_setCreateSchemaInfo;
+*setIgnoreAnnotations = *XML::Xercesc::AbstractDOMParser_setIgnoreAnnotations;
+*setDisableDefaultEntityResolution = *XML::Xercesc::AbstractDOMParser_setDisableDefaultEntityResolution;
+*setSkipDTDValidation = *XML::Xercesc::AbstractDOMParser_setSkipDTDValidation;
+*parse = *XML::Xercesc::AbstractDOMParser_parse;
+*parseFirst = *XML::Xercesc::AbstractDOMParser_parseFirst;
+*parseNext = *XML::Xercesc::AbstractDOMParser_parseNext;
+*parseReset = *XML::Xercesc::AbstractDOMParser_parseReset;
+*handleElementPSVI = *XML::Xercesc::AbstractDOMParser_handleElementPSVI;
+*handlePartialElementPSVI = *XML::Xercesc::AbstractDOMParser_handlePartialElementPSVI;
+*handleAttributesPSVI = *XML::Xercesc::AbstractDOMParser_handleAttributesPSVI;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::XercesDOMParser ##############
+
+package XML::Xerces::XercesDOMParser;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::AbstractDOMParser XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_XercesDOMParser(@_);
+ bless $self, $pkg if defined($self);
+}
+
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_XercesDOMParser($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getErrorHandler = *XML::Xercesc::XercesDOMParser_getErrorHandler;
+*getEntityResolver = *XML::Xercesc::XercesDOMParser_getEntityResolver;
+*getXMLEntityResolver = *XML::Xercesc::XercesDOMParser_getXMLEntityResolver;
+*isCachingGrammarFromParse = *XML::Xercesc::XercesDOMParser_isCachingGrammarFromParse;
+*isUsingCachedGrammarInParse = *XML::Xercesc::XercesDOMParser_isUsingCachedGrammarInParse;
+*getGrammar = *XML::Xercesc::XercesDOMParser_getGrammar;
+*getRootGrammar = *XML::Xercesc::XercesDOMParser_getRootGrammar;
+*getURIText = *XML::Xercesc::XercesDOMParser_getURIText;
+*getSrcOffset = *XML::Xercesc::XercesDOMParser_getSrcOffset;
+*getIgnoreCachedDTD = *XML::Xercesc::XercesDOMParser_getIgnoreCachedDTD;
+sub setErrorHandler {
+ my ($self,$handler) = @_;
+ my $callback = XML::Xerces::PerlErrorCallbackHandler->new($handler);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__ERROR_HANDLER} = $callback;
+
+ return XML::Xercesc::XercesDOMParser_setErrorHandler($self,$callback);
+}
+
+sub setEntityResolver {
+ my ($self,$handler) = @_;
+ my $callback = XML::Xerces::PerlEntityResolverHandler->new($handler);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__ENTITY_RESOLVER} = $callback;
+
+ return XML::Xercesc::XercesDOMParser_setEntityResolver($self,$callback);
+}
+
+*setXMLEntityResolver = *XML::Xercesc::XercesDOMParser_setXMLEntityResolver;
+*cacheGrammarFromParse = *XML::Xercesc::XercesDOMParser_cacheGrammarFromParse;
+*useCachedGrammarInParse = *XML::Xercesc::XercesDOMParser_useCachedGrammarInParse;
+*setIgnoreCachedDTD = *XML::Xercesc::XercesDOMParser_setIgnoreCachedDTD;
+*resetDocumentPool = *XML::Xercesc::XercesDOMParser_resetDocumentPool;
+*error = *XML::Xercesc::XercesDOMParser_error;
+*resetErrors = *XML::Xercesc::XercesDOMParser_resetErrors;
+*loadGrammar = *XML::Xercesc::XercesDOMParser_loadGrammar;
+*resetCachedGrammarPool = *XML::Xercesc::XercesDOMParser_resetCachedGrammarPool;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+############# Class : XML::Xerces::PerlNodeFilterCallbackHandler ##############
+
+package XML::Xerces::PerlNodeFilterCallbackHandler;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::DOMNodeFilter XML::Xerces::PerlCallbackHandler XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_PerlNodeFilterCallbackHandler(@_);
+ bless $self, $pkg if defined($self);
+}
+
+sub DESTROY {
+ return unless $_[0]->isa('HASH');
+ my $self = tied(%{$_[0]});
+ return unless defined $self;
+ delete $ITERATORS{$self};
+ if (exists $OWNER{$self}) {
+ XML::Xercesc::delete_PerlNodeFilterCallbackHandler($self);
+ delete $OWNER{$self};
+ }
+}
+
+*type = *XML::Xercesc::PerlNodeFilterCallbackHandler_type;
+*acceptNode = *XML::Xercesc::PerlNodeFilterCallbackHandler_acceptNode;
+sub DISOWN {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ delete $OWNER{$ptr};
+}
+
+sub ACQUIRE {
+ my $self = shift;
+ my $ptr = tied(%$self);
+ $OWNER{$ptr} = 1;
+}
+
+
+# ------- VARIABLE STUBS --------
+
+package XML::Xerces;
+
+1;
diff --git a/swig/perl/DOM/Makefile.PL b/swig/perl/DOM/Makefile.PL
new file mode 100644
index 000000000..a7233efcd
--- /dev/null
+++ b/swig/perl/DOM/Makefile.PL
@@ -0,0 +1,59 @@
+ #
+ # Copyright 2002,2004 The Apache Software Foundation.
+ #
+ # Licensed under the Apache License, Version 2.0 (the "License");
+ # you may not use this file except in compliance with the License.
+ # You may obtain a copy of the License at
+ #
+ # http://www.apache.org/licenses/LICENSE-2.0
+ #
+ # Unless required by applicable law or agreed to in writing, software
+ # distributed under the License is distributed on an "AS IS" BASIS,
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ # See the License for the specific language governing permissions and
+ # limitations under the License.
+ #
+
+use strict;
+
+my $BLIB_DIR = '../blib/lib/XML/Xerces';
+if ($XERCES_DEVEL) {
+ print STDERR "\tWelcome Xerces Developer!\n";
+
+ sub Xerces_DOM_postamble {
+ my $retval = <<TERMINUS;
+DOM-tmp.pm: $SCRIPTS_DIR/postModule.pl $INTERFACE_DIR/Perl/dom-shadow.i
+ \$(SWIG) $SWIG_ARGS -o Xerces_DOM-tmp.cpp -pm DOM-tmp.pm $INTERFACE_DIR/Xerces_DOM.i
+
+DOM.pm: $SCRIPTS_DIR/postModule.pl DOM-tmp.pm
+ perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postModule.pl --in=DOM-tmp.pm --out=DOM.pm
+
+Xerces_DOM.cpp: $SCRIPTS_DIR/postSource.pl Xerces_DOM-tmp.cpp
+ perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postSource.pl --in=Xerces_DOM-tmp.cpp --out=Xerces_DOM.cpp
+
+Xerces_DOM-tmp.cpp: $INTERFACE_DIR/Xerces_DOM.i
+ \$(SWIG) $SWIG_ARGS -o Xerces_DOM-tmp.cpp -pm DOM-tmp.pm $INTERFACE_DIR/Xerces_DOM.i
+ perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postModule.pl --in=DOM-tmp.pm --out=DOM.pm
+ mkdir -p $BLIB_DIR
+ cp -f DOM.pm $BLIB_DIR/DOM.pm
+
+TERMINUS
+ return $retval;
+ }
+
+ *MY::postamble = \&Xerces_DOM_postamble;
+}
+
+WriteMakefile(
+ 'NAME' => 'XML::Xerces::DOM',
+ 'INC' => $INCLUDES,
+ 'LIBS' => [$LIBS],
+ 'MYEXTLIB' => "$TRANSCODER_LIB $HANDLER_LIB",
+ 'OBJECT' => 'Xerces_DOM$(OBJ_EXT)',
+ 'CCFLAGS' => $CFLAGS,
+ 'CC' => $CXX,
+ 'SKIP' => [qw( test makeaperl xs_o)],
+ @OPTIMIZE,
+ @LDFLAGS,
+);
+
diff --git a/swig/perl/DOM/Xerces_DOM.cpp b/swig/perl/DOM/Xerces_DOM.cpp
new file mode 100644
index 000000000..3bec44af6
--- /dev/null
+++ b/swig/perl/DOM/Xerces_DOM.cpp
@@ -0,0 +1,29032 @@
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.30
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+#define SWIGPERL
+#define SWIG_CASTRANK_MODE
+
+#ifdef __cplusplus
+template<class T> class SwigValueWrapper {
+ T *tt;
+public:
+ SwigValueWrapper() : tt(0) { }
+ SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
+ SwigValueWrapper(const T& t) : tt(new T(t)) { }
+ ~SwigValueWrapper() { delete tt; }
+ SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
+ operator T&() const { return *tt; }
+ T *operator&() { return tt; }
+private:
+ SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+};
+#endif
+
+/* -----------------------------------------------------------------------------
+ * This section contains generic SWIG labels for method/variable
+ * declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC)
+# if (__SUNPRO_CC <= 0x560)
+# define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+# define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+# else
+# define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+# define SWIGINLINE inline
+# else
+# define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+# define SWIGUNUSED __attribute__ ((__unused__))
+# else
+# define SWIGUNUSED
+# endif
+# elif defined(__ICC)
+# define SWIGUNUSED __attribute__ ((__unused__))
+# else
+# define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+# define SWIGUNUSEDPARM(p)
+# else
+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+# ifndef GCC_HASCLASSVISIBILITY
+# define GCC_HASCLASSVISIBILITY
+# endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+# if defined(STATIC_LINKED)
+# define SWIGEXPORT
+# else
+# define SWIGEXPORT __declspec(dllexport)
+# endif
+# else
+# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+# define SWIGEXPORT __attribute__ ((visibility("default")))
+# else
+# define SWIGEXPORT
+# endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+# define SWIGSTDCALL __stdcall
+# else
+# define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic CAPI SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+ or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "3"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+ You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+ creating a static or dynamic library from the swig runtime code.
+ In 99.9% of the cases, swig just needs to declare them as 'static'.
+
+ But only do this if is strictly necessary, ie, if you have problems
+ with your compiler or so.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/* Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN 0x1
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN 0x1
+
+
+/*
+ Flags/methods for returning states.
+
+ The swig conversion methods, as ConvertPtr, return and integer
+ that tells if the conversion was successful or not. And if not,
+ an error code can be returned (see swigerrors.swg for the codes).
+
+ Use the following macros/flags to set or process the returning
+ states.
+
+ In old swig versions, you usually write code as:
+
+ if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+ // success code
+ } else {
+ //fail code
+ }
+
+ Now you can be more explicit as:
+
+ int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+ if (SWIG_IsOK(res)) {
+ // success code
+ } else {
+ // fail code
+ }
+
+ that seems to be the same, but now you can also do
+
+ Type *ptr;
+ int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+ if (SWIG_IsOK(res)) {
+ // success code
+ if (SWIG_IsNewObj(res) {
+ ...
+ delete *ptr;
+ } else {
+ ...
+ }
+ } else {
+ // fail code
+ }
+
+ I.e., now SWIG_ConvertPtr can return new objects and you can
+ identify the case and take care of the deallocation. Of course that
+ requires also to SWIG_ConvertPtr to return new result values, as
+
+ int SWIG_ConvertPtr(obj, ptr,...) {
+ if (<obj is ok>) {
+ if (<need new object>) {
+ *ptr = <ptr to new allocated object>;
+ return SWIG_NEWOBJ;
+ } else {
+ *ptr = <ptr to old object>;
+ return SWIG_OLDOBJ;
+ }
+ } else {
+ return SWIG_BADOBJ;
+ }
+ }
+
+ Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+ more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+ swig errors code.
+
+ Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+ allows to return the 'cast rank', for example, if you have this
+
+ int food(double)
+ int fooi(int);
+
+ and you call
+
+ food(1) // cast rank '1' (1 -> 1.0)
+ fooi(1) // cast rank '0'
+
+ just use the SWIG_AddCast()/SWIG_CheckState()
+
+
+ */
+#define SWIG_OK (0)
+#define SWIG_ERROR (-1)
+#define SWIG_IsOK(r) (r >= 0)
+#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ (SWIG_ERROR)
+#define SWIG_OLDOBJ (SWIG_OK)
+#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+# ifndef SWIG_TypeRank
+# define SWIG_TypeRank unsigned long
+# endif
+# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
+# define SWIG_MAXCASTRANK (2)
+# endif
+# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
+# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+ return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+# define SWIG_AddCast
+# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store inforomation on one type */
+typedef struct swig_type_info {
+ const char *name; /* mangled name of this type */
+ const char *str; /* human readable name of this type */
+ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
+ struct swig_cast_info *cast; /* linked list of types that can cast into this type */
+ void *clientdata; /* language specific type data */
+ int owndata; /* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+ swig_type_info *type; /* pointer to type that is equivalent to this type */
+ swig_converter_func converter; /* function to cast the void pointers */
+ struct swig_cast_info *next; /* pointer to next cast in linked list */
+ struct swig_cast_info *prev; /* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+ swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
+ size_t size; /* Number of types in this module */
+ struct swig_module_info *next; /* Pointer to next element in circularly linked list */
+ swig_type_info **type_initial; /* Array of initially generated type structures */
+ swig_cast_info **cast_initial; /* Array of initially generated casting structures */
+ void *clientdata; /* Language specific module data */
+} swig_module_info;
+
+/*
+ Compare two type names skipping the space characters, therefore
+ "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+ Return 0 when the two name types are equivalent, as in
+ strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+ const char *f2, const char *l2) {
+ for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+ while ((*f1 == ' ') && (f1 != l1)) ++f1;
+ while ((*f2 == ' ') && (f2 != l2)) ++f2;
+ if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+ }
+ return (l1 - f1) - (l2 - f2);
+}
+
+/*
+ Check type equivalence in a name list like <name1>|<name2>|...
+ Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+ int equiv = 0;
+ const char* te = tb + strlen(tb);
+ const char* ne = nb;
+ while (!equiv && *ne) {
+ for (nb = ne; *ne; ++ne) {
+ if (*ne == '|') break;
+ }
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+ if (*ne) ++ne;
+ }
+ return equiv;
+}
+
+/*
+ Check type equivalence in a name list like <name1>|<name2>|...
+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCompare(const char *nb, const char *tb) {
+ int equiv = 0;
+ const char* te = tb + strlen(tb);
+ const char* ne = nb;
+ while (!equiv && *ne) {
+ for (nb = ne; *ne; ++ne) {
+ if (*ne == '|') break;
+ }
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+ if (*ne) ++ne;
+ }
+ return equiv;
+}
+
+
+/* think of this as a c++ template<> or a scheme macro */
+#define SWIG_TypeCheck_Template(comparison, ty) \
+ if (ty) { \
+ swig_cast_info *iter = ty->cast; \
+ while (iter) { \
+ if (comparison) { \
+ if (iter == ty->cast) return iter; \
+ /* Move iter to the top of the linked list */ \
+ iter->prev->next = iter->next; \
+ if (iter->next) \
+ iter->next->prev = iter->prev; \
+ iter->next = ty->cast; \
+ iter->prev = 0; \
+ if (ty->cast) ty->cast->prev = iter; \
+ ty->cast = iter; \
+ return iter; \
+ } \
+ iter = iter->next; \
+ } \
+ } \
+ return 0
+
+/*
+ Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+ SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
+}
+
+/* Same as previous function, except strcmp is replaced with a pointer comparison */
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
+ SWIG_TypeCheck_Template(iter->type == from, into);
+}
+
+/*
+ Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
+ return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
+}
+
+/*
+ Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+ swig_type_info *lastty = ty;
+ if (!ty || !ty->dcast) return ty;
+ while (ty && (ty->dcast)) {
+ ty = (*ty->dcast)(ptr);
+ if (ty) lastty = ty;
+ }
+ return lastty;
+}
+
+/*
+ Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+ return ty->name;
+}
+
+/*
+ Return the pretty name associated with this type,
+ that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+ /* The "str" field contains the equivalent pretty names of the
+ type, separated by vertical-bar characters. We choose
+ to print the last name, as it is often (?) the most
+ specific. */
+ if (!type) return NULL;
+ if (type->str != NULL) {
+ const char *last_name = type->str;
+ const char *s;
+ for (s = type->str; *s; s++)
+ if (*s == '|') last_name = s+1;
+ return last_name;
+ }
+ else
+ return type->name;
+}
+
+/*
+ Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+ swig_cast_info *cast = ti->cast;
+ /* if (ti->clientdata == clientdata) return; */
+ ti->clientdata = clientdata;
+
+ while (cast) {
+ if (!cast->converter) {
+ swig_type_info *tc = cast->type;
+ if (!tc->clientdata) {
+ SWIG_TypeClientData(tc, clientdata);
+ }
+ }
+ cast = cast->next;
+ }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+ SWIG_TypeClientData(ti, clientdata);
+ ti->owndata = 1;
+}
+
+/*
+ Search for a swig_type_info structure only by mangled name
+ Search is a O(log #types)
+
+ We start searching at module start, and finish searching when start == end.
+ Note: if start == end at the beginning of the function, we go all the way around
+ the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
+ const char *name) {
+ swig_module_info *iter = start;
+ do {
+ if (iter->size) {
+ register size_t l = 0;
+ register size_t r = iter->size - 1;
+ do {
+ /* since l+r >= 0, we can (>> 1) instead (/ 2) */
+ register size_t i = (l + r) >> 1;
+ const char *iname = iter->types[i]->name;
+ if (iname) {
+ register int compare = strcmp(name, iname);
+ if (compare == 0) {
+ return iter->types[i];
+ } else if (compare < 0) {
+ if (i) {
+ r = i - 1;
+ } else {
+ break;
+ }
+ } else if (compare > 0) {
+ l = i + 1;
+ }
+ } else {
+ break; /* should never happen */
+ }
+ } while (l <= r);
+ }
+ iter = iter->next;
+ } while (iter != end);
+ return 0;
+}
+
+/*
+ Search for a swig_type_info structure for either a mangled name or a human readable name.
+ It first searches the mangled names of the types, which is a O(log #types)
+ If a type is not found it then searches the human readable names, which is O(#types).
+
+ We start searching at module start, and finish searching when start == end.
+ Note: if start == end at the beginning of the function, we go all the way around
+ the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
+ const char *name) {
+ /* STEP 1: Search the name field using binary search */
+ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+ if (ret) {
+ return ret;
+ } else {
+ /* STEP 2: If the type hasn't been found, do a complete search
+ of the str field (the human readable name) */
+ swig_module_info *iter = start;
+ do {
+ register size_t i = 0;
+ for (; i < iter->size; ++i) {
+ if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+ return iter->types[i];
+ }
+ iter = iter->next;
+ } while (iter != end);
+ }
+
+ /* neither found a match */
+ return 0;
+}
+
+/*
+ Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+ static const char hex[17] = "0123456789abcdef";
+ register const unsigned char *u = (unsigned char *) ptr;
+ register const unsigned char *eu = u + sz;
+ for (; u != eu; ++u) {
+ register unsigned char uu = *u;
+ *(c++) = hex[(uu & 0xf0) >> 4];
+ *(c++) = hex[uu & 0xf];
+ }
+ return c;
+}
+
+/*
+ Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+ register unsigned char *u = (unsigned char *) ptr;
+ register const unsigned char *eu = u + sz;
+ for (; u != eu; ++u) {
+ register char d = *(c++);
+ register unsigned char uu;
+ if ((d >= '0') && (d <= '9'))
+ uu = ((d - '0') << 4);
+ else if ((d >= 'a') && (d <= 'f'))
+ uu = ((d - ('a'-10)) << 4);
+ else
+ return (char *) 0;
+ d = *(c++);
+ if ((d >= '0') && (d <= '9'))
+ uu |= (d - '0');
+ else if ((d >= 'a') && (d <= 'f'))
+ uu |= (d - ('a'-10));
+ else
+ return (char *) 0;
+ *u = uu;
+ }
+ return c;
+}
+
+/*
+ Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+ char *r = buff;
+ if ((2*sizeof(void *) + 2) > bsz) return 0;
+ *(r++) = '_';
+ r = SWIG_PackData(r,&ptr,sizeof(void *));
+ if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+ strcpy(r,name);
+ return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+ if (*c != '_') {
+ if (strcmp(c,"NULL") == 0) {
+ *ptr = (void *) 0;
+ return name;
+ } else {
+ return 0;
+ }
+ }
+ return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+ char *r = buff;
+ size_t lname = (name ? strlen(name) : 0);
+ if ((2*sz + 2 + lname) > bsz) return 0;
+ *(r++) = '_';
+ r = SWIG_PackData(r,ptr,sz);
+ if (lname) {
+ strncpy(r,name,lname+1);
+ } else {
+ *r = 0;
+ }
+ return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+ if (*c != '_') {
+ if (strcmp(c,"NULL") == 0) {
+ memset(ptr,0,sz);
+ return name;
+ } else {
+ return 0;
+ }
+ }
+ return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Errors in SWIG */
+#define SWIG_UnknownError -1
+#define SWIG_IOError -2
+#define SWIG_RuntimeError -3
+#define SWIG_IndexError -4
+#define SWIG_TypeError -5
+#define SWIG_DivisionByZero -6
+#define SWIG_OverflowError -7
+#define SWIG_SyntaxError -8
+#define SWIG_ValueError -9
+#define SWIG_SystemError -10
+#define SWIG_AttributeError -11
+#define SWIG_MemoryError -12
+#define SWIG_NullReferenceError -13
+
+
+
+#ifdef __cplusplus
+/* Needed on some windows machines---since MS plays funny games with the header files under C++ */
+#include <math.h>
+#include <stdlib.h>
+extern "C" {
+#endif
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+/* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
+
+/* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
+#ifndef PERL_REVISION
+# if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
+# define PERL_PATCHLEVEL_H_IMPLICIT
+# include <patchlevel.h>
+# endif
+# if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
+# include <could_not_find_Perl_patchlevel.h>
+# endif
+# ifndef PERL_REVISION
+# define PERL_REVISION (5)
+# define PERL_VERSION PATCHLEVEL
+# define PERL_SUBVERSION SUBVERSION
+# endif
+#endif
+
+#if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
+#define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
+#endif
+
+#ifndef SvIOK_UV
+# define SvIOK_UV(sv) (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
+#endif
+
+#ifndef SvUOK
+# define SvUOK(sv) SvIOK_UV(sv)
+#endif
+
+#if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
+# define PL_sv_undef sv_undef
+# define PL_na na
+# define PL_errgv errgv
+# define PL_sv_no sv_no
+# define PL_sv_yes sv_yes
+# define PL_markstack_ptr markstack_ptr
+#endif
+
+#ifndef IVSIZE
+# ifdef LONGSIZE
+# define IVSIZE LONGSIZE
+# else
+# define IVSIZE 4 /* A bold guess, but the best we can make. */
+# endif
+#endif
+
+#ifndef INT2PTR
+# if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
+# define PTRV UV
+# define INT2PTR(any,d) (any)(d)
+# else
+# if PTRSIZE == LONGSIZE
+# define PTRV unsigned long
+# else
+# define PTRV unsigned
+# endif
+# define INT2PTR(any,d) (any)(PTRV)(d)
+# endif
+
+# define NUM2PTR(any,d) (any)(PTRV)(d)
+# define PTR2IV(p) INT2PTR(IV,p)
+# define PTR2UV(p) INT2PTR(UV,p)
+# define PTR2NV(p) NUM2PTR(NV,p)
+
+# if PTRSIZE == LONGSIZE
+# define PTR2ul(p) (unsigned long)(p)
+# else
+# define PTR2ul(p) INT2PTR(unsigned long,p)
+# endif
+#endif /* !INT2PTR */
+
+#ifndef get_sv
+# define get_sv perl_get_sv
+#endif
+
+#ifndef ERRSV
+# define ERRSV get_sv("@",FALSE)
+#endif
+
+#ifndef pTHX_
+#define pTHX_
+#endif
+
+#include <string.h>
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+SWIGINTERN const char*
+SWIG_Perl_ErrorType(int code) {
+ const char* type = 0;
+ switch(code) {
+ case SWIG_MemoryError:
+ type = "MemoryError";
+ break;
+ case SWIG_IOError:
+ type = "IOError";
+ break;
+ case SWIG_RuntimeError:
+ type = "RuntimeError";
+ break;
+ case SWIG_IndexError:
+ type = "IndexError";
+ break;
+ case SWIG_TypeError:
+ type = "TypeError";
+ break;
+ case SWIG_DivisionByZero:
+ type = "ZeroDivisionError";
+ break;
+ case SWIG_OverflowError:
+ type = "OverflowError";
+ break;
+ case SWIG_SyntaxError:
+ type = "SyntaxError";
+ break;
+ case SWIG_ValueError:
+ type = "ValueError";
+ break;
+ case SWIG_SystemError:
+ type = "SystemError";
+ break;
+ case SWIG_AttributeError:
+ type = "AttributeError";
+ break;
+ default:
+ type = "RuntimeError";
+ }
+ return type;
+}
+
+
+
+
+/* -----------------------------------------------------------------------------
+ * perlrun.swg
+ *
+ * This file contains the runtime support for Perl modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef PERL_OBJECT
+#define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
+#define SWIG_PERL_OBJECT_CALL pPerl,
+#else
+#define SWIG_PERL_OBJECT_DECL
+#define SWIG_PERL_OBJECT_CALL
+#endif
+
+/* Common SWIG API */
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
+#define SWIG_NewPointerObj(p, type, flags) SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, p, s, type) SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
+#define SWIG_NewPackedObj(p, s, type) SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type) SWIG_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata) SWIG_Perl_GetModule()
+#define SWIG_SetModule(clientdata, pointer) SWIG_Perl_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code) SWIG_Perl_ErrorType(code)
+#define SWIG_Error(code, msg) sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg)
+#define SWIG_fail goto fail
+
+/* Perl-specific SWIG API */
+
+#define SWIG_MakePtr(sv, ptr, type, flags) SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
+#define SWIG_MakePackedObj(sv, p, s, type) SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
+#define SWIG_SetError(str) SWIG_Error(SWIG_RuntimeError, str)
+
+
+#define SWIG_PERL_DECL_ARGS_1(arg1) (SWIG_PERL_OBJECT_DECL arg1)
+#define SWIG_PERL_CALL_ARGS_1(arg1) (SWIG_PERL_OBJECT_CALL arg1)
+#define SWIG_PERL_DECL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_DECL arg1, arg2)
+#define SWIG_PERL_CALL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_CALL arg1, arg2)
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION 0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SWIG_OWNER SWIG_POINTER_OWN
+#define SWIG_SHADOW SWIG_OWNER << 1
+
+#define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
+
+/* SWIG Perl macros */
+
+/* Macro to call an XS function */
+#ifdef PERL_OBJECT
+# define SWIG_CALLXS(_name) _name(cv,pPerl)
+#else
+# ifndef MULTIPLICITY
+# define SWIG_CALLXS(_name) _name(cv)
+# else
+# define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
+# endif
+#endif
+
+/* Note: SwigMagicFuncHack is a typedef used to get the C++ compiler to just shut up already */
+
+#ifdef PERL_OBJECT
+#define MAGIC_PPERL CPerlObj *pPerl = (CPerlObj *) this;
+typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (CPerlObj::*SwigMagicFuncHack)(SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
+#define SWIGCLASS_STATIC
+#else
+#define MAGIC_PPERL
+#define SWIGCLASS_STATIC static SWIGUNUSED
+#ifndef MULTIPLICITY
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
+typedef int (*SwigMagicFunc)(SV *, MAGIC *);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (*SwigMagicFuncHack)(SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+
+#else
+#define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
+typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (*SwigMagicFuncHack)(struct interpreter *, SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif
+
+/* Workaround for bug in perl 5.6.x croak and earlier */
+#if (PERL_VERSION < 8)
+# ifdef PERL_OBJECT
+# define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
+static void SWIG_Perl_croak_null(CPerlObj *pPerl)
+# else
+static void SWIG_croak_null()
+# endif
+{
+ SV *err=ERRSV;
+# if (PERL_VERSION < 6)
+ croak("%_", err);
+# else
+ if (SvOK(err) && !SvROK(err)) croak("%_", err);
+ croak(Nullch);
+# endif
+}
+#else
+# define SWIG_croak_null() croak(Nullch)
+#endif
+
+
+/*
+ Define how strict is the cast between strings an integers/doubles
+ when overloading between these types occurs.
+
+ The default is making it as strict as possible by using SWIG_AddCast
+ when needed.
+
+ You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
+ disable the SWIG_AddCast, making the casting between string and
+ numbers less strict.
+
+ In the end, we try to solve the overloading between strings and
+ numerical types in the more natural way, but if you can avoid it,
+ well, avoid it using %rename, for example.
+*/
+#ifndef SWIG_PERL_NO_STRICT_STR2NUM
+# ifndef SWIG_PERL_STRICT_STR2NUM
+# define SWIG_PERL_STRICT_STR2NUM
+# endif
+#endif
+#ifdef SWIG_PERL_STRICT_STR2NUM
+/* string takes precedence */
+#define SWIG_Str2NumCast(x) SWIG_AddCast(x)
+#else
+/* number takes precedence */
+#define SWIG_Str2NumCast(x) x
+#endif
+
+
+
+#include <stdlib.h>
+
+SWIGRUNTIME const char *
+SWIG_Perl_TypeProxyName(const swig_type_info *type) {
+ if (!type) return NULL;
+ if (type->clientdata != NULL) {
+ return (const char*) type->clientdata;
+ }
+ else {
+ return type->name;
+ }
+}
+
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
+ SWIG_TypeCheck_Template(( (!iter->type->clientdata && (strcmp((char*)iter->type->name, c) == 0))
+ || (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0))), ty);
+}
+
+
+/* Function for getting a pointer value */
+
+SWIGRUNTIME int
+SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
+ swig_cast_info *tc;
+ void *voidptr = (void *)0;
+ SV *tsv = 0;
+ /* If magical, apply more magic */
+ if (SvGMAGICAL(sv))
+ mg_get(sv);
+
+ /* Check to see if this is an object */
+ if (sv_isobject(sv)) {
+ IV tmp = 0;
+ tsv = (SV*) SvRV(sv);
+ if ((SvTYPE(tsv) == SVt_PVHV)) {
+ MAGIC *mg;
+ if (SvMAGICAL(tsv)) {
+ mg = mg_find(tsv,'P');
+ if (mg) {
+ sv = mg->mg_obj;
+ if (sv_isobject(sv)) {
+ tsv = (SV*)SvRV(sv);
+ tmp = SvIV(tsv);
+ }
+ }
+ } else {
+ return SWIG_ERROR;
+ }
+ } else {
+ tmp = SvIV(tsv);
+ }
+ voidptr = INT2PTR(void *,tmp);
+ } else if (! SvOK(sv)) { /* Check for undef */
+ *(ptr) = (void *) 0;
+ return SWIG_OK;
+ } else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
+ if (!SvROK(sv)) {
+ *(ptr) = (void *) 0;
+ return SWIG_OK;
+ } else {
+ return SWIG_ERROR;
+ }
+ } else { /* Don't know what it is */
+ return SWIG_ERROR;
+ }
+ if (_t) {
+ /* Now see if the types match */
+ char *_c = HvNAME(SvSTASH(SvRV(sv)));
+ tc = SWIG_TypeProxyCheck(_c,_t);
+ if (!tc) {
+ return SWIG_ERROR;
+ }
+ *ptr = SWIG_TypeCast(tc,voidptr);
+ } else {
+ *ptr = voidptr;
+ }
+
+ /*
+ * DISOWN implementation: we need a perl guru to check this one.
+ */
+ if (tsv && (flags & SWIG_POINTER_DISOWN)) {
+ /*
+ * almost copy paste code from below SWIG_POINTER_OWN setting
+ */
+ SV *obj = sv;
+ HV *stash = SvSTASH(SvRV(obj));
+ GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
+ if (isGV(gv)) {
+ HV *hv = GvHVn(gv);
+ /*
+ * To set ownership (see below), a newSViv(1) entry is added.
+ * Hence, to remove ownership, we delete the entry.
+ */
+ if (hv_exists_ent(hv, obj, 0)) {
+ hv_delete_ent(hv, obj, 0, 0);
+ }
+ }
+ }
+ return SWIG_OK;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
+ if (ptr && (flags & SWIG_SHADOW)) {
+ SV *self;
+ SV *obj=newSV(0);
+ HV *hash=newHV();
+ HV *stash;
+ sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
+ stash=SvSTASH(SvRV(obj));
+ if (flags & SWIG_POINTER_OWN) {
+ HV *hv;
+ GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+ if (!isGV(gv))
+ gv_init(gv, stash, "OWNER", 5, FALSE);
+ hv=GvHVn(gv);
+ hv_store_ent(hv, obj, newSViv(1), 0);
+ }
+ sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
+ SvREFCNT_dec(obj);
+ self=newRV_noinc((SV *)hash);
+ sv_setsv(sv, self);
+ SvREFCNT_dec((SV *)self);
+ sv_bless(sv, stash);
+ }
+ else {
+ sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr);
+ }
+}
+
+SWIGRUNTIMEINLINE SV *
+SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
+ SV *result = sv_newmortal();
+ SWIG_MakePtr(result, ptr, t, flags);
+ return result;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
+ char result[1024];
+ char *r = result;
+ if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
+ *(r++) = '_';
+ r = SWIG_PackData(r,ptr,sz);
+ strcpy(r,SWIG_Perl_TypeProxyName(type));
+ sv_setpv(sv, result);
+}
+
+SWIGRUNTIME SV *
+SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
+ SV *result = sv_newmortal();
+ SWIG_Perl_MakePackedObj(result, ptr, sz, type);
+ return result;
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
+ swig_cast_info *tc;
+ const char *c = 0;
+
+ if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
+ c = SvPV(obj, PL_na);
+ /* Pointer values must start with leading underscore */
+ if (*c != '_') return SWIG_ERROR;
+ c++;
+ c = SWIG_UnpackData(c,ptr,sz);
+ if (ty) {
+ tc = SWIG_TypeCheck(c,ty);
+ if (!tc) return SWIG_ERROR;
+ }
+ return SWIG_OK;
+}
+
+
+/* Macros for low-level exception handling */
+#define SWIG_croak(x) { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
+
+
+typedef XS(SwigPerlWrapper);
+typedef SwigPerlWrapper *SwigPerlWrapperPtr;
+
+/* Structure for command table */
+typedef struct {
+ const char *name;
+ SwigPerlWrapperPtr wrapper;
+} swig_command_info;
+
+/* Information for constant table */
+
+#define SWIG_INT 1
+#define SWIG_FLOAT 2
+#define SWIG_STRING 3
+#define SWIG_POINTER 4
+#define SWIG_BINARY 5
+
+/* Constant information structure */
+typedef struct swig_constant_info {
+ int type;
+ const char *name;
+ long lvalue;
+ double dvalue;
+ void *pvalue;
+ swig_type_info **ptype;
+} swig_constant_info;
+
+
+/* Structure for variable table */
+typedef struct {
+ const char *name;
+ SwigMagicFunc set;
+ SwigMagicFunc get;
+ swig_type_info **type;
+} swig_variable_info;
+
+/* Magic variable code */
+#ifndef PERL_OBJECT
+#define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
+ #ifndef MULTIPLICITY
+ SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
+ #else
+ SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
+ #endif
+#else
+# define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
+SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
+#endif
+{
+ MAGIC *mg;
+ sv_magic(sv,sv,'U',(char *) name,strlen(name));
+ mg = mg_find(sv,'U');
+ mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
+ mg->mg_virtual->svt_get = (SwigMagicFuncHack) get;
+ mg->mg_virtual->svt_set = (SwigMagicFuncHack) set;
+ mg->mg_virtual->svt_len = 0;
+ mg->mg_virtual->svt_clear = 0;
+ mg->mg_virtual->svt_free = 0;
+}
+
+
+SWIGRUNTIME swig_module_info *
+SWIG_Perl_GetModule(void) {
+ static void *type_pointer = (void *)0;
+ SV *pointer;
+
+ /* first check if pointer already created */
+ if (!type_pointer) {
+ pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE);
+ if (pointer && SvOK(pointer)) {
+ type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
+ }
+ }
+
+ return (swig_module_info *) type_pointer;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_SetModule(swig_module_info *module) {
+ SV *pointer;
+
+ /* create a new pointer */
+ pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE);
+ sv_setiv(pointer, PTR2IV(module));
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Workaround perl5 global namespace pollution. Note that undefining library
+ * functions like fopen will not solve the problem on all platforms as fopen
+ * might be a macro on Windows but not necessarily on other operating systems. */
+#ifdef do_open
+ #undef do_open
+#endif
+#ifdef do_close
+ #undef do_close
+#endif
+#ifdef scalar
+ #undef scalar
+#endif
+#ifdef list
+ #undef list
+#endif
+#ifdef apply
+ #undef apply
+#endif
+#ifdef convert
+ #undef convert
+#endif
+#ifdef Error
+ #undef Error
+#endif
+#ifdef form
+ #undef form
+#endif
+#ifdef vform
+ #undef vform
+#endif
+#ifdef LABEL
+ #undef LABEL
+#endif
+#ifdef METHOD
+ #undef METHOD
+#endif
+#ifdef Move
+ #undef Move
+#endif
+#ifdef yylex
+ #undef yylex
+#endif
+#ifdef yyparse
+ #undef yyparse
+#endif
+#ifdef yyerror
+ #undef yyerror
+#endif
+#ifdef invert
+ #undef invert
+#endif
+#ifdef ref
+ #undef ref
+#endif
+#ifdef read
+ #undef read
+#endif
+#ifdef write
+ #undef write
+#endif
+#ifdef eof
+ #undef eof
+#endif
+#ifdef bool
+ #undef bool
+#endif
+#ifdef close
+ #undef close
+#endif
+#ifdef rewind
+ #undef rewind
+#endif
+#ifdef free
+ #undef free
+#endif
+#ifdef malloc
+ #undef malloc
+#endif
+#ifdef calloc
+ #undef calloc
+#endif
+#ifdef Stat
+ #undef Stat
+#endif
+#ifdef check
+ #undef check
+#endif
+#ifdef seekdir
+ #undef seekdir
+#endif
+#ifdef open
+ #undef open
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
+
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_PSVIAttributeList swig_types[0]
+#define SWIGTYPE_p_PSVIElement swig_types[1]
+#define SWIGTYPE_p_PerlCallbackHandler swig_types[2]
+#define SWIGTYPE_p_PerlContentCallbackHandler swig_types[3]
+#define SWIGTYPE_p_PerlDocumentCallbackHandler swig_types[4]
+#define SWIGTYPE_p_PerlEntityResolverHandler swig_types[5]
+#define SWIGTYPE_p_PerlErrorCallbackHandler swig_types[6]
+#define SWIGTYPE_p_PerlNodeFilterCallbackHandler swig_types[7]
+#define SWIGTYPE_p_SecurityManager swig_types[8]
+#define SWIGTYPE_p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t swig_types[9]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser swig_types[10]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__BinInputStream swig_types[11]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr swig_types[12]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection swig_types[13]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData swig_types[14]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment swig_types[15]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration swig_types[16]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument swig_types[17]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment swig_types[18]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentRange swig_types[19]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal swig_types[20]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType swig_types[21]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement swig_types[22]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity swig_types[23]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference swig_types[24]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError swig_types[25]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMErrorHandler swig_types[26]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException swig_types[27]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation swig_types[28]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS swig_types[29]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList swig_types[30]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry swig_types[31]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource swig_types[32]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException swig_types[33]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput swig_types[34]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput swig_types[35]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser swig_types[36]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParserFilter swig_types[37]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver swig_types[38]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer swig_types[39]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter swig_types[40]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator swig_types[41]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap swig_types[42]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode swig_types[43]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter swig_types[44]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator swig_types[45]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList swig_types[46]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation swig_types[47]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo swig_types[48]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction swig_types[49]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange swig_types[50]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException swig_types[51]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList swig_types[52]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText swig_types[53]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker swig_types[54]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo swig_types[55]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler swig_types[56]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator swig_types[57]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException swig_types[58]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathExpression swig_types[59]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver swig_types[60]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNamespace swig_types[61]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult swig_types[62]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDAttDef swig_types[63]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDAttDefList swig_types[64]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDElementDecl swig_types[65]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDEntityDecl swig_types[66]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDGrammar swig_types[67]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDValidator swig_types[68]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler swig_types[69]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__EntityResolver swig_types[70]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler swig_types[71]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar swig_types[72]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase swig_types[73]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource swig_types[74]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget swig_types[75]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileInputSource swig_types[76]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget swig_types[77]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufInputSource swig_types[78]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager swig_types[79]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[80]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[81]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[82]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[83]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler swig_types[84]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__QName swig_types[85]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[86]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[87]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException swig_types[88]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException swig_types[89]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException swig_types[90]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException swig_types[91]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser swig_types[92]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaAttDef swig_types[93]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaAttDefList swig_types[94]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaElementDecl swig_types[95]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaGrammar swig_types[96]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaValidator swig_types[97]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdInInputSource swig_types[98]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget swig_types[99]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource swig_types[100]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput swig_types[101]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource swig_types[102]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttDef swig_types[103]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttDefList swig_types[104]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLContentModel swig_types[105]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDTDDescription swig_types[106]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLElementDecl swig_types[107]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityDecl swig_types[108]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityResolver swig_types[109]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLException swig_types[110]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget swig_types[111]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter swig_types[112]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription swig_types[113]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool swig_types[114]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLNotationDecl swig_types[115]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken swig_types[116]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLSchemaDescription swig_types[117]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLURL swig_types[118]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLUri swig_types[119]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator swig_types[120]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMemory swig_types[121]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser swig_types[122]
+#define SWIGTYPE_p_XMLErrorReporter__ErrTypes swig_types[123]
+#define SWIGTYPE_p_char swig_types[124]
+#define SWIGTYPE_p_int32_t swig_types[125]
+#define SWIGTYPE_p_size_t swig_types[126]
+#define SWIGTYPE_p_ssize_t swig_types[127]
+#define SWIGTYPE_p_uint16_t swig_types[128]
+#define SWIGTYPE_p_uint32_t swig_types[129]
+#define SWIGTYPE_p_unsigned_char swig_types[130]
+#define SWIGTYPE_p_void swig_types[131]
+static swig_type_info *swig_types[133];
+static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init boot_XML__Xerces__DOM
+
+#define SWIG_name "XML::Xercesc::boot_XML__Xerces__DOM"
+#define SWIG_prefix "XML::Xercesc::"
+
+#define SWIGVERSION 0x010330
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
+
+
+#include <stdexcept>
+
+
+#ifdef __cplusplus
+extern "C"
+#endif
+#ifndef PERL_OBJECT
+#ifndef MULTIPLICITY
+SWIGEXPORT void SWIG_init (CV* cv);
+#else
+SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
+#endif
+#else
+SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
+#endif
+
+
+#include "xercesc/sax/InputSource.hpp"
+#include "xercesc/sax/SAXException.hpp"
+#include "xercesc/sax/SAXParseException.hpp"
+#include "xercesc/sax/Locator.hpp"
+#include "xercesc/sax/HandlerBase.hpp"
+#include "xercesc/sax2/Attributes.hpp"
+#include "xercesc/sax2/ContentHandler.hpp"
+#include "xercesc/sax2/LexicalHandler.hpp"
+#include "xercesc/sax2/DefaultHandler.hpp"
+#include "xercesc/sax2/SAX2XMLReader.hpp"
+#include "xercesc/sax2/XMLReaderFactory.hpp"
+#include "xercesc/util/PlatformUtils.hpp"
+#include "xercesc/util/TransService.hpp"
+#include "xercesc/util/XMLString.hpp"
+#include "xercesc/util/XMLUri.hpp"
+#include "xercesc/util/QName.hpp"
+#include "xercesc/util/HexBin.hpp"
+#include "xercesc/util/Base64.hpp"
+#include "xercesc/parsers/SAXParser.hpp"
+#include "xercesc/framework/LocalFileInputSource.hpp"
+#include "xercesc/framework/MemBufInputSource.hpp"
+#include "xercesc/framework/StdInInputSource.hpp"
+#include "xercesc/framework/URLInputSource.hpp"
+#include "xercesc/framework/XMLGrammarDescription.hpp"
+#include "xercesc/framework/XMLDTDDescription.hpp"
+#include "xercesc/framework/XMLSchemaDescription.hpp"
+#include "xercesc/util/NameIdPool.hpp"
+#include "xercesc/util/XMLEnumerator.hpp"
+#include "xercesc/framework/XMLValidator.hpp"
+#include "xercesc/validators/common/Grammar.hpp"
+#include "xercesc/validators/DTD/DTDAttDef.hpp"
+#include "xercesc/validators/DTD/DTDAttDefList.hpp"
+#include "xercesc/validators/DTD/DTDGrammar.hpp"
+#include "xercesc/validators/DTD/DTDValidator.hpp"
+#include "xercesc/validators/schema/SchemaGrammar.hpp"
+#include "xercesc/validators/schema/SchemaValidator.hpp"
+#include "xercesc/validators/schema/SchemaAttDefList.hpp"
+#include "xercesc/validators/schema/SchemaAttDef.hpp"
+#include "xercesc/framework/XMLFormatter.hpp"
+#include "xercesc/framework/MemBufFormatTarget.hpp"
+#include "xercesc/framework/LocalFileFormatTarget.hpp"
+#include "xercesc/framework/StdOutFormatTarget.hpp"
+#include "xercesc/framework/psvi/PSVIHandler.hpp"
+
+
+
+#include "xercesc/dom/DOM.hpp"
+#include "xercesc/util/XMLException.hpp"
+#include "xercesc/framework/Wrapper4InputSource.hpp"
+#include "xercesc/framework/Wrapper4DOMLSInput.hpp"
+#include "xercesc/parsers/AbstractDOMParser.hpp"
+#include "xercesc/parsers/XercesDOMParser.hpp"
+#include "xercesc/framework/MemBufFormatTarget.hpp"
+#include "xercesc/framework/LocalFileFormatTarget.hpp"
+#include "xercesc/framework/StdOutFormatTarget.hpp"
+#include "xercesc/util/XMLUni.hpp"
+
+
+
+
+#define SWIG_SetErrorf SWIG_Perl_SetErrorf
+
+static void
+SWIG_Perl_SetErrorf(const char *fmt, ...) {
+ va_list args;
+ va_start(args, fmt);
+ sv_vsetpvfn(perl_get_sv("@", TRUE), fmt, strlen(fmt), &args, Null(SV**), 0, Null(bool*));
+ va_end(args);
+}
+
+SWIGRUNTIMEINLINE void
+SWIG_Perl_NullRef(const char *type, int argnum, const char *symname)
+{
+ if (type) {
+ SWIG_Perl_SetErrorf("null reference of type: '%s' was received as argumnent: %d of %s",type,argnum,symname);
+ } else {
+ SWIG_Perl_SetErrorf("null reference was received");
+ }
+}
+
+SWIGRUNTIMEINLINE void
+SWIG_Perl_NullRef(const char *type, const char *argname, const char *symname)
+{
+ if (type) {
+ SWIG_Perl_SetErrorf("null reference of type: '%s' was received as argumnent: %s of %s",type,argname,symname);
+ } else {
+ SWIG_Perl_SetErrorf("null reference was received");
+ }
+}
+
+SWIGRUNTIME void
+SWIG_Perl_TypeError(const char *type, int argnum, const char *symname)
+{
+ if (type) {
+ SWIG_Perl_SetErrorf("Type error in argument %d of %s. Expected %s", argnum, symname, type);
+ } else {
+ SWIG_Perl_SetErrorf("Type error in argument $argnum of $symname", argnum, symname);
+ }
+}
+
+
+
+static void
+SWIG_Disown(SV *sv) {
+
+ if (SvGMAGICAL(sv)) {
+ mg_get(sv);
+ }
+
+
+ /* Check to see if this is an object */
+ if (sv_isobject(sv)) {
+ SV *tsv = (SV*) SvRV(sv);
+ if ((SvTYPE(tsv) == SVt_PVHV)) {
+ MAGIC *mg;
+ if (SvMAGICAL(tsv)) {
+ mg = mg_find(tsv,'P');
+ if (mg) {
+ sv = mg->mg_obj;
+ if (sv_isobject(sv)) {
+ fprintf(stderr,"Found object for disown\n");
+
+ HV *stash;
+ stash=SvSTASH(SvRV(sv));
+
+ if (stash != 0)
+ {
+ fprintf(stderr,"Found stash: %x\n",stash);
+ HV *hv;
+ GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+ if (isGV(gv))
+ {
+ fprintf(stderr,"Found OWNER glob: %x\n",gv);
+ fprintf(stderr,"Found object: %x\n",sv);
+ fprintf(stderr,"Found ref object: %x\n",SvRV(sv));
+ hv=GvHVn(gv);
+
+ HE *entry;
+ char *key;
+ I32 klen;
+ SV *hval;
+
+ (void)hv_iterinit(hv);
+ while ((entry = hv_iternext(hv))) {
+ key = hv_iterkey(entry, &klen);
+ fprintf(stderr,"Found hash entry: %s\n",key);
+ }
+
+ if (hv_exists_ent(hv, sv, 0))
+ {
+ fprintf(stderr,"Found key in OWNER hash!\n");
+ if (hv_delete_ent(hv,sv,0,0))
+ {
+ fprintf(stderr,"Deleted key in OWNER hash!\n");
+ }
+ else
+ {
+ SWIG_SetError("Couldn't delete key from OWNER hash :-<\n");
+ }
+ }
+ else
+ {
+ SWIG_SetError("no key in OWNER hash :-<\n");
+ }
+ }
+ else
+ {
+ SWIG_SetError("no GV\n");
+ }
+ }
+ else
+ {
+ SWIG_SetError("no stash found\n");
+ }
+ } else {
+ SWIG_SetError("SWIG_Disown: mg is not object");
+ }
+ } else {
+ SWIG_SetError("SWIG_Disown: no mg");
+ }
+ } else {
+ SWIG_SetError("SWIG_Disown: not magical");
+ }
+ } else {
+ SWIG_SetError("SWIG_Disown: not PVHV");
+ }
+ } else { /* not an object */
+ SWIG_SetError("SWIG_Disown: not an object");
+ }
+}
+
+
+
+
+#include "Transcoder.hpp"
+#include "XMLExceptionHandler.hpp"
+
+#include "PerlCallbackHandler.hpp"
+#include "PerlErrorCallbackHandler.hpp"
+#include "PerlDocumentCallbackHandler.hpp"
+#include "PerlContentCallbackHandler.hpp"
+#include "PerlEntityResolverHandler.hpp"
+
+
+
+
+#include "PerlNodeFilterCallbackHandler.hpp"
+
+
+
+
+XERCES_CPP_NAMESPACE_USE
+
+// we initialize the static UTF-8 transcoding info
+// these are used by the typemaps to convert between
+// Xerces internal UTF-16 and Perl's internal UTF-8
+static Transcoder* UTF8_TRANSCODER = NULL;
+
+static XMLExceptionHandler* XML_EXCEPTION_HANDLER = NULL;
+
+void
+makeXMLException(const XMLException& e){
+ SV *error = ERRSV;
+ SWIG_MakePtr(error, (void *) XML_EXCEPTION_HANDLER->copyXMLException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLException, SWIG_SHADOW|0);
+}
+
+void
+makeDOMException(const DOMException& e){
+ SV *error = ERRSV;
+ SWIG_MakePtr(error, (void *) new DOMException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_SHADOW|0);
+}
+
+
+
+static swig_type_info *
+DOMNode_dynamic_cast(void **ptr) {
+ DOMNode **nptr = (DOMNode **) ptr;
+ if (*nptr == NULL) {
+ return NULL;
+ }
+ short int type = (*nptr)->getNodeType();
+ if (type == DOMNode::TEXT_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText;
+ }
+ if (type == DOMNode::PROCESSING_INSTRUCTION_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction;
+ }
+ if (type == DOMNode::DOCUMENT_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument;
+ }
+ if (type == DOMNode::ELEMENT_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement;
+ }
+ if (type == DOMNode::ENTITY_REFERENCE_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference;
+ }
+ if (type == DOMNode::CDATA_SECTION_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection;
+ }
+ if (type == DOMNode::CDATA_SECTION_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection;
+ }
+ if (type == DOMNode::COMMENT_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment;
+ }
+ if (type == DOMNode::DOCUMENT_TYPE_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType;
+ }
+ if (type == DOMNode::ENTITY_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity;
+ }
+ if (type == DOMNode::ATTRIBUTE_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr;
+ }
+ if (type == DOMNode::NOTATION_NODE) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation;
+ }
+ return NULL;
+}
+
+
+#define CATCH_DOM_EXCEPTION \
+ catch (const XMLException& e) \
+ { \
+ makeXMLException(e); \
+ goto fail; \
+ } \
+ catch (const DOMException& e) \
+ { \
+ makeDOMException(e); \
+ goto fail; \
+ } \
+ catch (...) \
+ { \
+ SWIG_croak("Handling Unknown exception"); \
+ goto fail; \
+ }
+
+
+#include <limits.h>
+#ifndef LLONG_MIN
+# define LLONG_MIN LONG_LONG_MIN
+#endif
+#ifndef LLONG_MAX
+# define LLONG_MAX LONG_LONG_MAX
+#endif
+#ifndef ULLONG_MAX
+# define ULLONG_MAX ULONG_LONG_MAX
+#endif
+
+
+SWIGINTERN int
+SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
+{
+ if (SvNIOK(obj)) {
+ if (val) *val = SvNV(obj);
+ return SWIG_OK;
+ } else if (SvIOK(obj)) {
+ if (val) *val = (double) SvIV(obj);
+ return SWIG_AddCast(SWIG_OK);
+ } else {
+ const char *nptr = SvPV(obj, PL_na);
+ if (nptr) {
+ char *endptr;
+ double v = strtod(nptr, &endptr);
+ if (errno == ERANGE) {
+ errno = 0;
+ return SWIG_OverflowError;
+ } else {
+ if (*endptr == '\0') {
+ if (val) *val = v;
+ return SWIG_Str2NumCast(SWIG_OK);
+ }
+ }
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+#include <float.h>
+
+
+#include <math.h>
+
+
+SWIGINTERNINLINE int
+SWIG_CanCastAsInteger(double *d, double min, double max) {
+ double x = *d;
+ if ((min <= x && x <= max)) {
+ double fx = floor(x);
+ double cx = ceil(x);
+ double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
+ if ((errno == EDOM) || (errno == ERANGE)) {
+ errno = 0;
+ } else {
+ double summ, reps, diff;
+ if (rd < x) {
+ diff = x - rd;
+ } else if (rd > x) {
+ diff = rd - x;
+ } else {
+ return 1;
+ }
+ summ = rd + x;
+ reps = diff/summ;
+ if (reps < 8*DBL_EPSILON) {
+ *d = rd;
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
+{
+ if (SvIOK(obj)) {
+ if (val) *val = SvIV(obj);
+ return SWIG_OK;
+ } else {
+ int dispatch = 0;
+ const char *nptr = SvPV(obj, PL_na);
+ if (nptr) {
+ char *endptr;
+ long v = strtol(nptr, &endptr,0);
+ if (errno == ERANGE) {
+ errno = 0;
+ return SWIG_OverflowError;
+ } else {
+ if (*endptr == '\0') {
+ if (val) *val = v;
+ return SWIG_Str2NumCast(SWIG_OK);
+ }
+ }
+ }
+ if (!dispatch) {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
+ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
+ if (val) *val = (long)(d);
+ return res;
+ }
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_short SWIG_PERL_DECL_ARGS_2(SV * obj, short *val)
+{
+ long v;
+ int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v < SHRT_MIN || v > SHRT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = static_cast< short >(v);
+ }
+ }
+ return res;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value)
+{
+ SV *obj = sv_newmortal();
+ sv_setiv(obj, (IV) value);
+ return obj;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_int SWIG_PERL_DECL_ARGS_1(int value)
+{
+ return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
+{
+ long v;
+ int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v < INT_MIN || v > INT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = static_cast< int >(v);
+ }
+ }
+ return res;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_short SWIG_PERL_DECL_ARGS_1(short value)
+{
+ return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_bool SWIG_PERL_DECL_ARGS_2(SV *obj, bool* val)
+{
+ if (obj == &PL_sv_yes) {
+ if (val) *val = true;
+ return SWIG_OK;
+ } else if (obj == &PL_sv_no) {
+ if (val) *val = false;
+ return SWIG_OK;
+ } else {
+ if (val) *val = SvTRUE(obj) ? true: false;
+ return SWIG_AddCast(SWIG_OK);
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_bool SWIG_PERL_DECL_ARGS_1(bool value)
+{
+ SV *obj = sv_newmortal();
+ if (value) {
+ sv_setsv(obj, &PL_sv_yes);
+ } else {
+ sv_setsv(obj, &PL_sv_no);
+ }
+ return obj;
+}
+
+SWIGINTERN bool XERCES_CPP_NAMESPACE_DOMNode_operator_Se__Se_(XERCES_CPP_NAMESPACE::DOMNode *self,XERCES_CPP_NAMESPACE::DOMNode const *other){
+ return self->isSameNode(other);
+ }
+SWIGINTERN bool XERCES_CPP_NAMESPACE_DOMNode_operator_SN__Se_(XERCES_CPP_NAMESPACE::DOMNode *self,XERCES_CPP_NAMESPACE::DOMNode const *other){
+ return !self->isSameNode(other);
+ }
+
+SWIGINTERNINLINE SV *
+SWIG_From_unsigned_SS_long SWIG_PERL_DECL_ARGS_1(unsigned long value)
+{
+ SV *obj = sv_newmortal();
+ sv_setuv(obj, (UV) value);
+ return obj;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_size_t SWIG_PERL_DECL_ARGS_1(size_t value)
+{
+ return SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(static_cast< unsigned long >(value));
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
+{
+ if (SvUOK(obj)) {
+ if (val) *val = SvUV(obj);
+ return SWIG_OK;
+ } else if (SvIOK(obj)) {
+ long v = SvIV(obj);
+ if (v >= 0) {
+ if (val) *val = v;
+ return SWIG_OK;
+ } else {
+ return SWIG_OverflowError;
+ }
+ } else {
+ int dispatch = 0;
+ const char *nptr = SvPV(obj, PL_na);
+ if (nptr) {
+ char *endptr;
+ unsigned long v = strtoul(nptr, &endptr,0);
+ if (errno == ERANGE) {
+ errno = 0;
+ return SWIG_OverflowError;
+ } else {
+ if (*endptr == '\0') {
+ if (val) *val = v;
+ return SWIG_Str2NumCast(SWIG_OK);
+ }
+ }
+ }
+ if (!dispatch) {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
+ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
+ if (val) *val = (unsigned long)(d);
+ return res;
+ }
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE int
+SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
+{
+ unsigned long v;
+ int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
+ if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
+ return res;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_short SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned short *val)
+{
+ unsigned long v;
+ int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v > USHRT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = static_cast< unsigned short >(v);
+ }
+ }
+ return res;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_double SWIG_PERL_DECL_ARGS_1(double value)
+{
+ SV *obj = sv_newmortal();
+ sv_setnv(obj, value);
+ return obj;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_int SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned int *val)
+{
+ unsigned long v;
+ int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v > UINT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = static_cast< unsigned int >(v);
+ }
+ }
+ return res;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_From_unsigned_SS_int SWIG_PERL_DECL_ARGS_1(unsigned int value)
+{
+ return SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(value);
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+ SV *obj = sv_newmortal();
+ if (carray) {
+ if (size && (carray[size - 1] == 0)) {
+ sv_setpv(obj, carray);
+ } else {
+ char *tmp = (new char[size + 1]);
+ memcpy(tmp, carray, size);
+ tmp[size] = 0;
+ sv_setpv(obj, tmp);
+ delete[] tmp;
+ }
+ } else {
+ sv_setsv(obj, &PL_sv_undef);
+ }
+ return obj;
+}
+
+
+SWIGINTERNINLINE SV *
+SWIG_FromCharPtr(const char *cptr)
+{
+ return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+ static int init = 0;
+ static swig_type_info* info = 0;
+ if (!init) {
+ info = SWIG_TypeQuery("_p_char");
+ init = 1;
+ }
+ return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
+{
+ if (SvPOK(obj)) {
+ STRLEN len = 0;
+ char *cstr = SvPV(obj, len);
+ size_t size = len + 1;
+ if (cptr) {
+ if (alloc) {
+ if (*alloc == SWIG_NEWOBJ) {
+ *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size)));
+ } else {
+ *cptr = cstr;
+ *alloc = SWIG_OLDOBJ;
+ }
+ }
+ }
+ if (psize) *psize = size;
+ return SWIG_OK;
+ } else {
+ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+ if (pchar_descriptor) {
+ char* vptr = 0;
+ if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
+ if (cptr) *cptr = vptr;
+ if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
+ if (alloc) *alloc = SWIG_OLDOBJ;
+ return SWIG_OK;
+ }
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+
+
+#ifdef PERL_OBJECT
+#define MAGIC_CLASS _wrap_XML::Xerces_var::
+class _wrap_XML::Xerces_var : public CPerlObj {
+public:
+#else
+#define MAGIC_CLASS
+#endif
+SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
+ MAGIC_PPERL
+ croak("Value is read-only.");
+ return 0;
+}
+
+
+#ifdef PERL_OBJECT
+};
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+XS(_wrap_new_DOMException__SWIG_0) {
+ {
+ short arg1 ;
+ short arg2 ;
+ XERCES_CPP_NAMESPACE::MemoryManager *arg3 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
+ XERCES_CPP_NAMESPACE::DOMException *result = 0 ;
+ short val1 ;
+ int ecode1 = 0 ;
+ short val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: new_DOMException(code,messageCode,memoryManager);");
+ }
+ ecode1 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMException" "', argument " "1"" of type '" "short""'");
+ }
+ arg1 = static_cast< short >(val1);
+ ecode2 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DOMException" "', argument " "2"" of type '" "short""'");
+ }
+ arg2 = static_cast< short >(val2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DOMException" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMException *)new XERCES_CPP_NAMESPACE::DOMException(arg1,arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMException__SWIG_1) {
+ {
+ short arg1 ;
+ short arg2 ;
+ XERCES_CPP_NAMESPACE::DOMException *result = 0 ;
+ short val1 ;
+ int ecode1 = 0 ;
+ short val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: new_DOMException(code,messageCode);");
+ }
+ ecode1 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMException" "', argument " "1"" of type '" "short""'");
+ }
+ arg1 = static_cast< short >(val1);
+ ecode2 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DOMException" "', argument " "2"" of type '" "short""'");
+ }
+ arg2 = static_cast< short >(val2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMException *)new XERCES_CPP_NAMESPACE::DOMException(arg1,arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMException__SWIG_2) {
+ {
+ short arg1 ;
+ XERCES_CPP_NAMESPACE::DOMException *result = 0 ;
+ short val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_DOMException(code);");
+ }
+ ecode1 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMException" "', argument " "1"" of type '" "short""'");
+ }
+ arg1 = static_cast< short >(val1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMException *)new XERCES_CPP_NAMESPACE::DOMException(arg1);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMException) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 1) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_3:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMException__SWIG_2); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMException__SWIG_1); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMException__SWIG_0); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_DOMException'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_DOMException) {
+ {
+ XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMException(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMException_getMessage) {
+ {
+ XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMException_getMessage(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMException_getMessage" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMException const *)arg1)->getMessage();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMException_code_set) {
+ {
+ XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMException::ExceptionCode arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMException_code_set(self,code);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMException_code_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMException_code_set" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMException::ExceptionCode""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMException::ExceptionCode >(val2);
+ if (arg1) (arg1)->code = arg2;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMException_code_get) {
+ {
+ XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMException::ExceptionCode result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMException_code_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMException_code_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
+ result = (XERCES_CPP_NAMESPACE::DOMException::ExceptionCode) ((arg1)->code);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMException_msg_set) {
+ {
+ XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMException_msg_set(self,msg);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMException_msg_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMException_msg_set");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ if (arg1) (arg1)->msg = (XMLCh const *)arg2;
+
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMException_msg_get) {
+ {
+ XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMException_msg_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMException_msg_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
+ result = (XMLCh *) ((arg1)->msg);
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMNode(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getNodeName) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getNodeName(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getNodeName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNodeName();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getNodeValue) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getNodeValue(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getNodeValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNodeValue();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getNodeType) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ short result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getNodeType(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getNodeType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (short)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNodeType();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getParentNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getParentNode(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getParentNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getParentNode();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getChildNodes) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getChildNodes(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getChildNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getChildNodes();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getFirstChild) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getFirstChild(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getFirstChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getFirstChild();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getLastChild) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getLastChild(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getLastChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getLastChild();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getPreviousSibling) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getPreviousSibling(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getPreviousSibling" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getPreviousSibling();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getNextSibling) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getNextSibling(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getNextSibling" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNextSibling();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getAttributes) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getAttributes(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getAttributes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getAttributes();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getOwnerDocument) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getOwnerDocument(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getOwnerDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocument *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getOwnerDocument();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_cloneNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ bool arg2 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_cloneNode(self,deep);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_cloneNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMNode_cloneNode" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->cloneNode(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_insertBefore) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg3 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMNode_insertBefore(self,newChild,refChild);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_insertBefore" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_insertBefore" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMNode_insertBefore" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->insertBefore(arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_replaceChild) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg3 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMNode_replaceChild(self,newChild,oldChild);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_replaceChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_replaceChild" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMNode_replaceChild" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->replaceChild(arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_removeChild) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_removeChild(self,oldChild);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_removeChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_removeChild" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->removeChild(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_appendChild) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_appendChild(self,newChild);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_appendChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_appendChild" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->appendChild(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_hasChildNodes) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_hasChildNodes(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_hasChildNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->hasChildNodes();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_setNodeValue) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_setNodeValue(self,nodeValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_setNodeValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNode_setNodeValue");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setNodeValue((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_normalize) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_normalize(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_normalize" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ (arg1)->normalize();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_isSupported) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMNode_isSupported(self,feature,version);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_isSupported" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNode_isSupported");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMNode_isSupported");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isSupported((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getNamespaceURI) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getNamespaceURI(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getNamespaceURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNamespaceURI();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getLocalName) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getLocalName(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getLocalName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getLocalName();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_setPrefix) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_setPrefix(self,prefix);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_setPrefix" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNode_setPrefix");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setPrefix((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_hasAttributes) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_hasAttributes(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_hasAttributes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->hasAttributes();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_isSameNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_isSameNode(self,other);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_isSameNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_isSameNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isSameNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_isEqualNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_isEqualNode(self,arg);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_isEqualNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_isEqualNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isEqualNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_setUserData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *arg3 = (void *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMUserDataHandler *arg4 = (XERCES_CPP_NAMESPACE::DOMUserDataHandler *) 0 ;
+ void *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMNode_setUserData(self,key,data,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_setUserData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNode_setUserData");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ arg3 = (void*) ST(2);
+ }
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMNode_setUserData" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::DOMUserDataHandler *""'");
+ }
+ arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMUserDataHandler * >(argp4);
+ {
+ try
+ {
+ result = (void *)(arg1)->setUserData((XMLCh const *)arg2,arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getUserData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_getUserData(self,key);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getUserData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNode_getUserData");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (void *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getUserData((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getBaseURI) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getBaseURI(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getBaseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getBaseURI();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_compareDocumentPosition) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ short result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_compareDocumentPosition(self,other);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_compareDocumentPosition" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_compareDocumentPosition" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (short)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->compareDocumentPosition((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getTextContent) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_getTextContent(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getTextContent" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getTextContent();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_setTextContent) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_setTextContent(self,textContent);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_setTextContent" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNode_setTextContent");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setTextContent((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_lookupPrefix) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_lookupPrefix(self,namespaceURI);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_lookupPrefix" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNode_lookupPrefix");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->lookupPrefix((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_isDefaultNamespace) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_isDefaultNamespace(self,namespaceURI);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_isDefaultNamespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNode_isDefaultNamespace");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isDefaultNamespace((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_lookupNamespaceURI) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode_lookupNamespaceURI(self,prefix);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_lookupNamespaceURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNode_lookupNamespaceURI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->lookupNamespaceURI((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_getFeature) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ void *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMNode_getFeature(self,feature,version);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getFeature" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNode_getFeature");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMNode_getFeature");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (void *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getFeature((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode_release) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNode_release(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ {
+ try
+ {
+ (arg1)->release();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode___eq__) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode___eq__(self,other);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode___eq__" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode___eq__" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (bool)XERCES_CPP_NAMESPACE_DOMNode_operator_Se__Se_(arg1,(XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNode___ne__) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNode___ne__(self,other);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode___ne__" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode___ne__" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (bool)XERCES_CPP_NAMESPACE_DOMNode_operator_SN__Se_(arg1,(XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMAttr) {
+ {
+ XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMAttr(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMAttr" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMAttr_getName) {
+ {
+ XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMAttr_getName(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_getName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getName();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMAttr_getSpecified) {
+ {
+ XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMAttr_getSpecified(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_getSpecified" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getSpecified();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMAttr_getValue) {
+ {
+ XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMAttr_getValue(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getValue();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMAttr_setValue) {
+ {
+ XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMAttr_setValue(self,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_setValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMAttr_setValue");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setValue((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMAttr_getOwnerElement) {
+ {
+ XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMAttr_getOwnerElement(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_getOwnerElement" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getOwnerElement();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMAttr_isId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMAttr_isId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_isId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->isId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMAttr_getSchemaTypeInfo) {
+ {
+ XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMTypeInfo *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMAttr_getSchemaTypeInfo(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_getSchemaTypeInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMTypeInfo *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getSchemaTypeInfo();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMElement) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMElement(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMElement" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_getTagName) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMElement_getTagName(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getTagName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getTagName();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_getAttribute) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMElement_getAttribute(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_getAttribute");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttribute((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_getAttributeNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMElement_getAttributeNode(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getAttributeNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_getAttributeNode");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMAttr *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttributeNode((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_getElementsByTagName) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMElement_getElementsByTagName(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getElementsByTagName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_getElementsByTagName");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getElementsByTagName((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_setAttribute) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMElement_setAttribute(self,name,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_setAttribute");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMElement_setAttribute");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ (arg1)->setAttribute((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_setAttributeNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMElement_setAttributeNode(self,newAttr);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setAttributeNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMElement_setAttributeNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->setAttributeNode(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_removeAttributeNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMElement_removeAttributeNode(self,oldAttr);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_removeAttributeNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMElement_removeAttributeNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->removeAttributeNode(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_removeAttribute) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMElement_removeAttribute(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_removeAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_removeAttribute");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->removeAttribute((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_getAttributeNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMElement_getAttributeNS(self,namespaceURI,localName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_getAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMElement_getAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_setAttributeNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XMLCh *arg4 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMElement_setAttributeNS(self,namespaceURI,qualifiedName,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_setAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMElement_setAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DOMElement_setAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
+ }
+
+ {
+ try
+ {
+ (arg1)->setAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_removeAttributeNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMElement_removeAttributeNS(self,namespaceURI,localName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_removeAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_removeAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMElement_removeAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ (arg1)->removeAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_getAttributeNodeNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMElement_getAttributeNodeNS(self,namespaceURI,localName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getAttributeNodeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_getAttributeNodeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMElement_getAttributeNodeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMAttr *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttributeNodeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_setAttributeNodeNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMElement_setAttributeNodeNS(self,newAttr);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setAttributeNodeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMElement_setAttributeNodeNS" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->setAttributeNodeNS(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_getElementsByTagNameNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMElement_getElementsByTagNameNS(self,namespaceURI,localName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getElementsByTagNameNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_getElementsByTagNameNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMElement_getElementsByTagNameNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getElementsByTagNameNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_hasAttribute) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMElement_hasAttribute(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_hasAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_hasAttribute");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->hasAttribute((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_hasAttributeNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMElement_hasAttributeNS(self,namespaceURI,localName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_hasAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_hasAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMElement_hasAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->hasAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_setIdAttribute) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ bool arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMElement_setIdAttribute(self,name,isId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setIdAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_setIdAttribute");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMElement_setIdAttribute" "', argument " "3"" of type '" "bool""'");
+ }
+ arg3 = static_cast< bool >(val3);
+ {
+ try
+ {
+ (arg1)->setIdAttribute((XMLCh const *)arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_setIdAttributeNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ bool arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMElement_setIdAttributeNS(self,namespaceURI,localName,isId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setIdAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMElement_setIdAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMElement_setIdAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ ecode4 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMElement_setIdAttributeNS" "', argument " "4"" of type '" "bool""'");
+ }
+ arg4 = static_cast< bool >(val4);
+ {
+ try
+ {
+ (arg1)->setIdAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_setIdAttributeNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ bool arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ bool val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMElement_setIdAttributeNode(self,idAttr,isId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setIdAttributeNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMElement_setIdAttributeNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp2);
+ ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMElement_setIdAttributeNode" "', argument " "3"" of type '" "bool""'");
+ }
+ arg3 = static_cast< bool >(val3);
+ {
+ try
+ {
+ (arg1)->setIdAttributeNode((XERCES_CPP_NAMESPACE::DOMAttr const *)arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMElement_getSchemaTypeInfo) {
+ {
+ XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMTypeInfo *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMElement_getSchemaTypeInfo(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getSchemaTypeInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMTypeInfo *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getSchemaTypeInfo();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMEntity) {
+ {
+ XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMEntity(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMEntity_getPublicId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMEntity_getPublicId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getPublicId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMEntity_getSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMEntity_getSystemId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getSystemId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMEntity_getNotationName) {
+ {
+ XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMEntity_getNotationName(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getNotationName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getNotationName();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMEntity_getInputEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMEntity_getInputEncoding(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getInputEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getInputEncoding();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMEntity_getXmlEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMEntity_getXmlEncoding(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getXmlEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getXmlEncoding();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMEntity_getXmlVersion) {
+ {
+ XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMEntity_getXmlVersion(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getXmlVersion" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getXmlVersion();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMDocumentType) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMDocumentType(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMDocumentType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocumentType_getName) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocumentType_getName(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getName();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocumentType_getEntities) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocumentType_getEntities(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getEntities" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getEntities();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocumentType_getNotations) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocumentType_getNotations(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getNotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getNotations();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocumentType_getPublicId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocumentType_getPublicId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getPublicId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocumentType_getSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocumentType_getSystemId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getSystemId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocumentType_getInternalSubset) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocumentType_getInternalSubset(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getInternalSubset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getInternalSubset();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMCharacterData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMCharacterData(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMCharacterData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMCharacterData_getData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMCharacterData_getData(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_getData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMCharacterData const *)arg1)->getData();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMCharacterData_getLength) {
+ {
+ XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+ XMLSize_t result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMCharacterData_getLength(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::DOMCharacterData const *)arg1)->getLength();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMCharacterData_substringData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+ XMLSize_t arg2 ;
+ XMLSize_t arg3 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMCharacterData_substringData(self,offset,count);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_substringData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMCharacterData_substringData" "', argument " "2"" of type '" "XMLSize_t""'");
+ }
+ arg2 = static_cast< XMLSize_t >(val2);
+ ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMCharacterData_substringData" "', argument " "3"" of type '" "XMLSize_t""'");
+ }
+ arg3 = static_cast< XMLSize_t >(val3);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMCharacterData const *)arg1)->substringData(arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMCharacterData_appendData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMCharacterData_appendData(self,arg);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_appendData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMCharacterData_appendData");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->appendData((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMCharacterData_insertData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+ XMLSize_t arg2 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMCharacterData_insertData(self,offset,arg);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_insertData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMCharacterData_insertData" "', argument " "2"" of type '" "XMLSize_t""'");
+ }
+ arg2 = static_cast< XMLSize_t >(val2);
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMCharacterData_insertData");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ (arg1)->insertData(arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMCharacterData_deleteData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+ XMLSize_t arg2 ;
+ XMLSize_t arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMCharacterData_deleteData(self,offset,count);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_deleteData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMCharacterData_deleteData" "', argument " "2"" of type '" "XMLSize_t""'");
+ }
+ arg2 = static_cast< XMLSize_t >(val2);
+ ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMCharacterData_deleteData" "', argument " "3"" of type '" "XMLSize_t""'");
+ }
+ arg3 = static_cast< XMLSize_t >(val3);
+ {
+ try
+ {
+ (arg1)->deleteData(arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMCharacterData_replaceData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+ XMLSize_t arg2 ;
+ XMLSize_t arg3 ;
+ XMLCh *arg4 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMCharacterData_replaceData(self,offset,count,arg);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_replaceData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMCharacterData_replaceData" "', argument " "2"" of type '" "XMLSize_t""'");
+ }
+ arg2 = static_cast< XMLSize_t >(val2);
+ ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMCharacterData_replaceData" "', argument " "3"" of type '" "XMLSize_t""'");
+ }
+ arg3 = static_cast< XMLSize_t >(val3);
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DOMCharacterData_replaceData");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
+ }
+
+ {
+ try
+ {
+ (arg1)->replaceData(arg2,arg3,(XMLCh const *)arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+
+ delete[] arg4;
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ delete[] arg4;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMCharacterData_setData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMCharacterData_setData(self,data);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_setData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMCharacterData_setData");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setData((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMComment) {
+ {
+ XERCES_CPP_NAMESPACE::DOMComment *arg1 = (XERCES_CPP_NAMESPACE::DOMComment *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMComment(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMComment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMComment *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMComment * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMText) {
+ {
+ XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMText(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMText_splitText) {
+ {
+ XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+ XMLSize_t arg2 ;
+ XERCES_CPP_NAMESPACE::DOMText *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMText_splitText(self,offset);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMText_splitText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMText_splitText" "', argument " "2"" of type '" "XMLSize_t""'");
+ }
+ arg2 = static_cast< XMLSize_t >(val2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMText *)(arg1)->splitText(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMText_getIsElementContentWhitespace) {
+ {
+ XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMText_getIsElementContentWhitespace(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMText_getIsElementContentWhitespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMText const *)arg1)->getIsElementContentWhitespace();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMText_getWholeText) {
+ {
+ XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMText_getWholeText(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMText_getWholeText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMText const *)arg1)->getWholeText();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMText_replaceWholeText) {
+ {
+ XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMText *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMText_replaceWholeText(self,content);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMText_replaceWholeText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMText_replaceWholeText");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMText *)(arg1)->replaceWholeText((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMText_isIgnorableWhitespace) {
+ {
+ XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMText_isIgnorableWhitespace(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMText_isIgnorableWhitespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMText const *)arg1)->isIgnorableWhitespace();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMCDATASection) {
+ {
+ XERCES_CPP_NAMESPACE::DOMCDATASection *arg1 = (XERCES_CPP_NAMESPACE::DOMCDATASection *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMCDATASection(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMCDATASection" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCDATASection *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCDATASection * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMNodeList) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeList *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeList *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMNodeList(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNodeList" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeList *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeList * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNodeList_item) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeList *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeList *) 0 ;
+ XMLSize_t arg2 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNodeList_item(self,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeList_item" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeList const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeList * >(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMNodeList_item" "', argument " "2"" of type '" "XMLSize_t""'");
+ }
+ arg2 = static_cast< XMLSize_t >(val2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNodeList const *)arg1)->item(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNodeList_getLength) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeList *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeList *) 0 ;
+ XMLSize_t result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNodeList_getLength(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeList_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeList const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeList * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::DOMNodeList const *)arg1)->getLength();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMNamedNodeMap) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMNamedNodeMap(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNamedNodeMap" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNamedNodeMap_setNamedItem) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNamedNodeMap_setNamedItem(self,arg);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_setNamedItem" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNamedNodeMap_setNamedItem" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->setNamedItem(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNamedNodeMap_item) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+ XMLSize_t arg2 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNamedNodeMap_item(self,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_item" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMNamedNodeMap_item" "', argument " "2"" of type '" "XMLSize_t""'");
+ }
+ arg2 = static_cast< XMLSize_t >(val2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->item(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNamedNodeMap_getNamedItem) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNamedNodeMap_getNamedItem(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_getNamedItem" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNamedNodeMap_getNamedItem");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->getNamedItem((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNamedNodeMap_getLength) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+ XMLSize_t result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNamedNodeMap_getLength(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->getLength();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNamedNodeMap_removeNamedItem) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNamedNodeMap_removeNamedItem(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_removeNamedItem" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNamedNodeMap_removeNamedItem");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->removeNamedItem((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNamedNodeMap_getNamedItemNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMNamedNodeMap_getNamedItemNS(self,namespaceURI,localName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_getNamedItemNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNamedNodeMap_getNamedItemNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMNamedNodeMap_getNamedItemNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->getNamedItemNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNamedNodeMap_setNamedItemNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNamedNodeMap_setNamedItemNS(self,arg);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_setNamedItemNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNamedNodeMap_setNamedItemNS" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->setNamedItemNS(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNamedNodeMap_removeNamedItemNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMNamedNodeMap_removeNamedItemNS(self,namespaceURI,localName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_removeNamedItemNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMNamedNodeMap_removeNamedItemNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMNamedNodeMap_removeNamedItemNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->removeNamedItemNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMDocumentFragment) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentFragment *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentFragment *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMDocumentFragment(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMDocumentFragment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentFragment *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentFragment * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMEntityReference) {
+ {
+ XERCES_CPP_NAMESPACE::DOMEntityReference *arg1 = (XERCES_CPP_NAMESPACE::DOMEntityReference *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMEntityReference(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMEntityReference" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntityReference *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntityReference * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMNotation) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNotation *arg1 = (XERCES_CPP_NAMESPACE::DOMNotation *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMNotation(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNotation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNotation *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNotation * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNotation_getPublicId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNotation *arg1 = (XERCES_CPP_NAMESPACE::DOMNotation *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNotation_getPublicId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNotation_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNotation const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNotation * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNotation const *)arg1)->getPublicId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNotation_getSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNotation *arg1 = (XERCES_CPP_NAMESPACE::DOMNotation *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNotation_getSystemId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNotation_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNotation const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNotation * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNotation const *)arg1)->getSystemId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMProcessingInstruction) {
+ {
+ XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMProcessingInstruction(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMProcessingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMProcessingInstruction *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMProcessingInstruction * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMProcessingInstruction_getTarget) {
+ {
+ XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMProcessingInstruction_getTarget(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMProcessingInstruction_getTarget" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMProcessingInstruction * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *)arg1)->getTarget();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMProcessingInstruction_getData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMProcessingInstruction_getData(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMProcessingInstruction_getData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMProcessingInstruction * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *)arg1)->getData();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMProcessingInstruction_setData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMProcessingInstruction_setData(self,data);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMProcessingInstruction_setData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMProcessingInstruction *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMProcessingInstruction * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMProcessingInstruction_setData");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setData((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMTypeInfo) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMTypeInfo *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMTypeInfo(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMTypeInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTypeInfo *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTypeInfo * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTypeInfo_getTypeName) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMTypeInfo *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTypeInfo_getTypeName(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTypeInfo_getTypeName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTypeInfo const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTypeInfo * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMTypeInfo const *)arg1)->getTypeName();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTypeInfo_getTypeNamespace) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMTypeInfo *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTypeInfo_getTypeNamespace(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTypeInfo_getTypeNamespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTypeInfo const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTypeInfo * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMTypeInfo const *)arg1)->getTypeNamespace();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTypeInfo_isDerivedFrom) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMTypeInfo *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ unsigned long arg4 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ unsigned long val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMTypeInfo_isDerivedFrom(self,typeNamespaceArg,typeNameArg,derivationMethod);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTypeInfo_isDerivedFrom" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTypeInfo const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTypeInfo * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMTypeInfo_isDerivedFrom");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMTypeInfo_isDerivedFrom");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ ecode4 = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMTypeInfo_isDerivedFrom" "', argument " "4"" of type '" "unsigned long""'");
+ }
+ arg4 = static_cast< unsigned long >(val4);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMTypeInfo const *)arg1)->isDerivedFrom((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMPSVITypeInfo) {
+ {
+ XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMPSVITypeInfo(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMPSVITypeInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMPSVITypeInfo * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMPSVITypeInfo_getStringProperty) {
+ {
+ XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty arg2 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMPSVITypeInfo_getStringProperty(self,prop);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMPSVITypeInfo_getStringProperty" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMPSVITypeInfo * >(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMPSVITypeInfo_getStringProperty" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty >(val2);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMPSVITypeInfo const *)arg1)->getStringProperty(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMPSVITypeInfo_getNumericProperty) {
+ {
+ XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty arg2 ;
+ int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMPSVITypeInfo_getNumericProperty(self,prop);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMPSVITypeInfo_getNumericProperty" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMPSVITypeInfo * >(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMPSVITypeInfo_getNumericProperty" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty >(val2);
+ {
+ try
+ {
+ result = (int)((XERCES_CPP_NAMESPACE::DOMPSVITypeInfo const *)arg1)->getNumericProperty(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMXPathEvaluator) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathEvaluator *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathEvaluator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMXPathEvaluator(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathEvaluator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathEvaluator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathEvaluator * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathEvaluator_createExpression) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathEvaluator *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathEvaluator *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMXPathNSResolver *arg3 = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMXPathExpression *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMXPathEvaluator_createExpression(self,expression,resolver);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathEvaluator_createExpression" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathEvaluator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathEvaluator * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMXPathEvaluator_createExpression");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMXPathEvaluator_createExpression" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNSResolver * >(argp3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMXPathExpression *)(arg1)->createExpression((XMLCh const *)arg2,(XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathExpression, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathEvaluator_createNSResolver) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathEvaluator *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathEvaluator *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMXPathNSResolver *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMXPathEvaluator_createNSResolver(self,nodeResolver);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathEvaluator_createNSResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathEvaluator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathEvaluator * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMXPathEvaluator_createNSResolver" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *)(arg1)->createNSResolver(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathEvaluator_evaluate) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathEvaluator *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathEvaluator *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg3 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMXPathNSResolver *arg4 = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *) 0 ;
+ unsigned short arg5 ;
+ void *arg6 = (void *) 0 ;
+ void *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ unsigned short val5 ;
+ int ecode5 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 6) || (items > 6)) {
+ SWIG_croak("Usage: DOMXPathEvaluator_evaluate(self,expression,contextNode,resolver,type,result);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathEvaluator_evaluate" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathEvaluator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathEvaluator * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMXPathEvaluator_evaluate");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMXPathEvaluator_evaluate" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMXPathEvaluator_evaluate" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *""'");
+ }
+ arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNSResolver * >(argp4);
+ ecode5 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DOMXPathEvaluator_evaluate" "', argument " "5"" of type '" "unsigned short""'");
+ }
+ arg5 = static_cast< unsigned short >(val5);
+ {
+ arg6 = (void*) ST(5);
+ }
+ {
+ try
+ {
+ result = (void *)(arg1)->evaluate((XMLCh const *)arg2,arg3,(XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *)arg4,arg5,arg6);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
+
+ delete[] arg2;
+
+
+
+
+
+ delete[] arg6;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+
+
+
+ delete[] arg6;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMXPathException__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathException *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_DOMXPathException();");
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMXPathException *)new XERCES_CPP_NAMESPACE::DOMXPathException();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMXPathException__SWIG_1) {
+ {
+ short arg1 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMXPathException *result = 0 ;
+ short val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: new_DOMXPathException(code,message);");
+ }
+ ecode1 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMXPathException" "', argument " "1"" of type '" "short""'");
+ }
+ arg1 = static_cast< short >(val1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"new_DOMXPathException");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMXPathException *)new XERCES_CPP_NAMESPACE::DOMXPathException(arg1,(XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMXPathException__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = 0 ;
+ XERCES_CPP_NAMESPACE::DOMXPathException *result = 0 ;
+ void *argp1 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_DOMXPathException(other);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DOMXPathException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException const &""'");
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DOMXPathException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException const &""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMXPathException *)new XERCES_CPP_NAMESPACE::DOMXPathException((XERCES_CPP_NAMESPACE::DOMXPathException const &)*arg1);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMXPathException) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 0) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ if (items == 1) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_3:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMXPathException__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMXPathException__SWIG_2); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMXPathException__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_DOMXPathException'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_DOMXPathException) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathException *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMXPathException(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathException_code_set) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathException *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMXPathException::ExceptionCode arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMXPathException_code_set(self,code);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathException_code_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMXPathException_code_set" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException::ExceptionCode""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMXPathException::ExceptionCode >(val2);
+ if (arg1) (arg1)->code = arg2;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathException_code_get) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathException *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMXPathException::ExceptionCode result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMXPathException_code_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathException_code_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
+ result = (XERCES_CPP_NAMESPACE::DOMXPathException::ExceptionCode) ((arg1)->code);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathException_msg_set) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathException *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMXPathException_msg_set(self,msg);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathException_msg_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMXPathException_msg_set");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ if (arg1) (arg1)->msg = (XMLCh const *)arg2;
+
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathException_msg_get) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathException *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMXPathException_msg_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathException_msg_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
+ result = (XMLCh *) ((arg1)->msg);
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMXPathExpression) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathExpression *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathExpression *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMXPathExpression(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathExpression, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathExpression" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathExpression *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathExpression * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathExpression_evaluate) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathExpression *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathExpression *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ unsigned short arg3 ;
+ void *arg4 = (void *) 0 ;
+ void *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ unsigned short val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMXPathExpression_evaluate(self,contextNode,type,result);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathExpression, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathExpression_evaluate" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathExpression const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathExpression * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMXPathExpression_evaluate" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ ecode3 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMXPathExpression_evaluate" "', argument " "3"" of type '" "unsigned short""'");
+ }
+ arg3 = static_cast< unsigned short >(val3);
+ {
+ arg4 = (void*) ST(3);
+ }
+ {
+ try
+ {
+ result = (void *)((XERCES_CPP_NAMESPACE::DOMXPathExpression const *)arg1)->evaluate(arg2,arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
+
+
+
+ delete[] arg4;
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ delete[] arg4;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMXPathNamespace) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathNamespace *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathNamespace *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMXPathNamespace(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNamespace, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathNamespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNamespace *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNamespace * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathNamespace_getOwnerElement) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathNamespace *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathNamespace *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMXPathNamespace_getOwnerElement(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNamespace, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathNamespace_getOwnerElement" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNamespace const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNamespace * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMXPathNamespace const *)arg1)->getOwnerElement();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMXPathNSResolver) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathNSResolver *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMXPathNSResolver(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathNSResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNSResolver *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNSResolver * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathNSResolver_lookupNamespaceURI) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathNSResolver *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMXPathNSResolver_lookupNamespaceURI(self,prefix);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathNSResolver_lookupNamespaceURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNSResolver * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMXPathNSResolver_lookupNamespaceURI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *)arg1)->lookupNamespaceURI((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathNSResolver_lookupPrefix) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathNSResolver *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMXPathNSResolver_lookupPrefix(self,URI);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathNSResolver_lookupPrefix" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNSResolver * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMXPathNSResolver_lookupPrefix");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *)arg1)->lookupPrefix((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMXPathResult) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMXPathResult(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathResult" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathResult_getBooleanValue) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMXPathResult_getBooleanValue(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getBooleanValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getBooleanValue();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathResult_getInvalidIteratorState) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMXPathResult_getInvalidIteratorState(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getInvalidIteratorState" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getInvalidIteratorState();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathResult_getNumberValue) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
+ double result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMXPathResult_getNumberValue(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getNumberValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
+ {
+ try
+ {
+ result = (double)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getNumberValue();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1(static_cast< double >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathResult_getResultType) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
+ short result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMXPathResult_getResultType(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getResultType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
+ {
+ try
+ {
+ result = (short)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getResultType();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathResult_getSingleNodeValue) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMXPathResult_getSingleNodeValue(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getSingleNodeValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getSingleNodeValue();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathResult_getSnapshotLength) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
+ unsigned long result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMXPathResult_getSnapshotLength(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getSnapshotLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
+ {
+ try
+ {
+ result = (unsigned long)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getSnapshotLength();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(static_cast< unsigned long >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathResult_getStringValue) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMXPathResult_getStringValue(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getStringValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getStringValue();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathResult_iterateNext) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMXPathResult_iterateNext(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_iterateNext" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->iterateNext();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMXPathResult_snapshotItem) {
+ {
+ XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
+ unsigned long arg2 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ unsigned long val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMXPathResult_snapshotItem(self,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_snapshotItem" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMXPathResult_snapshotItem" "', argument " "2"" of type '" "unsigned long""'");
+ }
+ arg2 = static_cast< unsigned long >(val2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->snapshotItem(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMDocumentRange) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentRange *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentRange *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMDocumentRange(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentRange, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMDocumentRange" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentRange * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocumentRange_createRange) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentRange *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMRange *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocumentRange_createRange(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentRange_createRange" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentRange * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMRange *)(arg1)->createRange();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMDocumentTraversal) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentTraversal *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentTraversal *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMDocumentTraversal(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMDocumentTraversal" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentTraversal *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentTraversal * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocumentTraversal_createNodeIterator) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentTraversal *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentTraversal *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ unsigned long arg3 ;
+ XERCES_CPP_NAMESPACE::DOMNodeFilter *arg4 = (XERCES_CPP_NAMESPACE::DOMNodeFilter *) 0 ;
+ bool arg5 ;
+ XERCES_CPP_NAMESPACE::DOMNodeIterator *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ unsigned long val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ bool val5 ;
+ int ecode5 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: DOMDocumentTraversal_createNodeIterator(self,root,whatToShow,filter,entityReferenceExpansion);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentTraversal_createNodeIterator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentTraversal *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentTraversal * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMDocumentTraversal_createNodeIterator" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ ecode3 = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMDocumentTraversal_createNodeIterator" "', argument " "3"" of type '" "unsigned long""'");
+ }
+ arg3 = static_cast< unsigned long >(val3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMDocumentTraversal_createNodeIterator" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeFilter *""'");
+ }
+ arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeFilter * >(argp4);
+ ecode5 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DOMDocumentTraversal_createNodeIterator" "', argument " "5"" of type '" "bool""'");
+ }
+ arg5 = static_cast< bool >(val5);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNodeIterator *)(arg1)->createNodeIterator(arg2,arg3,arg4,arg5);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocumentTraversal_createTreeWalker) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocumentTraversal *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentTraversal *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ unsigned long arg3 ;
+ XERCES_CPP_NAMESPACE::DOMNodeFilter *arg4 = (XERCES_CPP_NAMESPACE::DOMNodeFilter *) 0 ;
+ bool arg5 ;
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ unsigned long val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ bool val5 ;
+ int ecode5 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: DOMDocumentTraversal_createTreeWalker(self,root,whatToShow,filter,entityReferenceExpansion);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentTraversal_createTreeWalker" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentTraversal *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentTraversal * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMDocumentTraversal_createTreeWalker" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ ecode3 = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMDocumentTraversal_createTreeWalker" "', argument " "3"" of type '" "unsigned long""'");
+ }
+ arg3 = static_cast< unsigned long >(val3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMDocumentTraversal_createTreeWalker" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeFilter *""'");
+ }
+ arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeFilter * >(argp4);
+ ecode5 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DOMDocumentTraversal_createTreeWalker" "', argument " "5"" of type '" "bool""'");
+ }
+ arg5 = static_cast< bool >(val5);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMTreeWalker *)(arg1)->createTreeWalker(arg2,arg3,arg4,arg5);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMNodeIterator) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMNodeIterator(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNodeIterator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNodeIterator_getRoot) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNodeIterator_getRoot(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_getRoot" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->getRoot();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNodeIterator_getWhatToShow) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
+ unsigned long result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNodeIterator_getWhatToShow(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_getWhatToShow" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
+ {
+ try
+ {
+ result = (unsigned long)(arg1)->getWhatToShow();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(static_cast< unsigned long >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNodeIterator_getFilter) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNodeFilter *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNodeIterator_getFilter(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_getFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNodeFilter *)(arg1)->getFilter();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNodeIterator_getExpandEntityReferences) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNodeIterator_getExpandEntityReferences(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_getExpandEntityReferences" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
+ {
+ try
+ {
+ result = (bool)(arg1)->getExpandEntityReferences();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNodeIterator_nextNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNodeIterator_nextNode(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_nextNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->nextNode();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNodeIterator_previousNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNodeIterator_previousNode(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_previousNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->previousNode();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNodeIterator_detach) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNodeIterator_detach(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_detach" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
+ {
+ try
+ {
+ (arg1)->detach();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNodeIterator_release) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMNodeIterator_release(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
+ {
+ try
+ {
+ (arg1)->release();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMNodeFilter) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeFilter *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeFilter *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMNodeFilter(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNodeFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeFilter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeFilter * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMNodeFilter_acceptNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMNodeFilter *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeFilter *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ short result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMNodeFilter_acceptNode(self,node);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeFilter_acceptNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeFilter const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeFilter * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNodeFilter_acceptNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (short)((XERCES_CPP_NAMESPACE::DOMNodeFilter const *)arg1)->acceptNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMRange) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMRange(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMRange" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_getStartContainer) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_getStartContainer(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getStartContainer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getStartContainer();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_getStartOffset) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XMLSize_t result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_getStartOffset(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getStartOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getStartOffset();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_getEndContainer) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_getEndContainer(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getEndContainer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getEndContainer();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_getEndOffset) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XMLSize_t result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_getEndOffset(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getEndOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getEndOffset();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_getCollapsed) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_getCollapsed(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getCollapsed" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getCollapsed();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_getCommonAncestorContainer) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_getCommonAncestorContainer(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getCommonAncestorContainer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getCommonAncestorContainer();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_setStart) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLSize_t arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMRange_setStart(self,refNode,offset);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setStart" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setStart" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMRange_setStart" "', argument " "3"" of type '" "XMLSize_t""'");
+ }
+ arg3 = static_cast< XMLSize_t >(val3);
+ {
+ try
+ {
+ (arg1)->setStart((XERCES_CPP_NAMESPACE::DOMNode const *)arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_setEnd) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLSize_t arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMRange_setEnd(self,refNode,offset);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setEnd" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setEnd" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMRange_setEnd" "', argument " "3"" of type '" "XMLSize_t""'");
+ }
+ arg3 = static_cast< XMLSize_t >(val3);
+ {
+ try
+ {
+ (arg1)->setEnd((XERCES_CPP_NAMESPACE::DOMNode const *)arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_setStartBefore) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMRange_setStartBefore(self,refNode);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setStartBefore" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setStartBefore" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ (arg1)->setStartBefore((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_setStartAfter) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMRange_setStartAfter(self,refNode);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setStartAfter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setStartAfter" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ (arg1)->setStartAfter((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_setEndBefore) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMRange_setEndBefore(self,refNode);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setEndBefore" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setEndBefore" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ (arg1)->setEndBefore((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_setEndAfter) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMRange_setEndAfter(self,refNode);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setEndAfter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setEndAfter" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ (arg1)->setEndAfter((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_collapse) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMRange_collapse(self,toStart);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_collapse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMRange_collapse" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->collapse(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_selectNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMRange_selectNode(self,refNode);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_selectNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_selectNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ (arg1)->selectNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_selectNodeContents) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMRange_selectNodeContents(self,refNode);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_selectNodeContents" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_selectNodeContents" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ (arg1)->selectNodeContents((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_compareBoundaryPoints) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMRange::CompareHow arg2 ;
+ XERCES_CPP_NAMESPACE::DOMRange *arg3 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ short result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMRange_compareBoundaryPoints(self,how,sourceRange);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_compareBoundaryPoints" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMRange_compareBoundaryPoints" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMRange::CompareHow""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMRange::CompareHow >(val2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMRange_compareBoundaryPoints" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp3);
+ {
+ try
+ {
+ result = (short)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->compareBoundaryPoints(arg2,(XERCES_CPP_NAMESPACE::DOMRange const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_deleteContents) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_deleteContents(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_deleteContents" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ (arg1)->deleteContents();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_extractContents) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocumentFragment *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_extractContents(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_extractContents" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocumentFragment *)(arg1)->extractContents();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_cloneContents) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocumentFragment *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_cloneContents(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_cloneContents" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocumentFragment *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->cloneContents();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_insertNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMRange_insertNode(self,newNode);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_insertNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_insertNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ (arg1)->insertNode(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_surroundContents) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMRange_surroundContents(self,newParent);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_surroundContents" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_surroundContents" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ (arg1)->surroundContents(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_cloneRange) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMRange *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_cloneRange(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_cloneRange" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMRange *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->cloneRange();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_toString) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_toString(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_toString" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->toString();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_detach) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_detach(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_detach" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ (arg1)->detach();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRange_release) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRange_release(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
+ {
+ try
+ {
+ (arg1)->release();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMRangeException) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode arg1 ;
+ short arg2 ;
+ XERCES_CPP_NAMESPACE::MemoryManager *arg3 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
+ XERCES_CPP_NAMESPACE::DOMRangeException *result = 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ short val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: new_DOMRangeException(code,messageCode,memoryManager);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMRangeException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode""'");
+ }
+ arg1 = static_cast< XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode >(val1);
+ ecode2 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DOMRangeException" "', argument " "2"" of type '" "short""'");
+ }
+ arg2 = static_cast< short >(val2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DOMRangeException" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMRangeException *)new XERCES_CPP_NAMESPACE::DOMRangeException(arg1,arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMRangeException) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRangeException *arg1 = (XERCES_CPP_NAMESPACE::DOMRangeException *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMRangeException(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMRangeException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRangeException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRangeException * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRangeException_code_set) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRangeException *arg1 = (XERCES_CPP_NAMESPACE::DOMRangeException *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMRangeException_code_set(self,code);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRangeException_code_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRangeException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRangeException * >(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMRangeException_code_set" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode >(val2);
+ if (arg1) (arg1)->code = arg2;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMRangeException_code_get) {
+ {
+ XERCES_CPP_NAMESPACE::DOMRangeException *arg1 = (XERCES_CPP_NAMESPACE::DOMRangeException *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMRangeException_code_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRangeException_code_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRangeException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRangeException * >(argp1);
+ result = (XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode) ((arg1)->code);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMTreeWalker) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMTreeWalker(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMTreeWalker" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_getRoot) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_getRoot(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_getRoot" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->getRoot();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_getWhatToShow) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ unsigned long result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_getWhatToShow(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_getWhatToShow" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (unsigned long)(arg1)->getWhatToShow();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(static_cast< unsigned long >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_getFilter) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNodeFilter *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_getFilter(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_getFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNodeFilter *)(arg1)->getFilter();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_getExpandEntityReferences) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_getExpandEntityReferences(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_getExpandEntityReferences" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (bool)(arg1)->getExpandEntityReferences();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_getCurrentNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_getCurrentNode(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_getCurrentNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->getCurrentNode();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_parentNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_parentNode(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_parentNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->parentNode();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_firstChild) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_firstChild(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_firstChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->firstChild();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_lastChild) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_lastChild(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_lastChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->lastChild();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_previousSibling) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_previousSibling(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_previousSibling" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->previousSibling();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_nextSibling) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_nextSibling(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_nextSibling" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->nextSibling();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_previousNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_previousNode(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_previousNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->previousNode();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_nextNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_nextNode(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_nextNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->nextNode();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_setCurrentNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMTreeWalker_setCurrentNode(self,currentNode);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_setCurrentNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMTreeWalker_setCurrentNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ (arg1)->setCurrentNode(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMTreeWalker_release) {
+ {
+ XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMTreeWalker_release(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
+ {
+ try
+ {
+ (arg1)->release();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMUserDataHandler) {
+ {
+ XERCES_CPP_NAMESPACE::DOMUserDataHandler *arg1 = (XERCES_CPP_NAMESPACE::DOMUserDataHandler *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMUserDataHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMUserDataHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMUserDataHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMUserDataHandler * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMUserDataHandler_handle) {
+ {
+ XERCES_CPP_NAMESPACE::DOMUserDataHandler *arg1 = (XERCES_CPP_NAMESPACE::DOMUserDataHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMUserDataHandler::DOMOperationType arg2 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ void *arg4 = (void *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg5 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg6 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 6) || (items > 6)) {
+ SWIG_croak("Usage: DOMUserDataHandler_handle(self,operation,key,data,src,dst);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMUserDataHandler_handle" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMUserDataHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMUserDataHandler * >(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMUserDataHandler_handle" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMUserDataHandler::DOMOperationType""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMUserDataHandler::DOMOperationType >(val2);
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMUserDataHandler_handle");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ arg4 = (void*) ST(3);
+ }
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DOMUserDataHandler_handle" "', argument " "5"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg5 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp5);
+ res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DOMUserDataHandler_handle" "', argument " "6"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg6 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp6);
+ {
+ try
+ {
+ (arg1)->handle(arg2,(XMLCh const *)arg3,arg4,(XERCES_CPP_NAMESPACE::DOMNode const *)arg5,(XERCES_CPP_NAMESPACE::DOMNode const *)arg6);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMConfiguration_setParameter__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *arg3 = (void *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMConfiguration_setParameter(self,name,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_setParameter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMConfiguration_setParameter");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ // now check the value
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMConfiguration_setParameter");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+ }
+ {
+ try
+ {
+ (arg1)->setParameter((XMLCh const *)arg2,(void const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMConfiguration_setParameter__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ bool arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMConfiguration_setParameter(self,name,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_setParameter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMConfiguration_setParameter");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMConfiguration_setParameter" "', argument " "3"" of type '" "bool""'");
+ }
+ arg3 = static_cast< bool >(val3);
+ {
+ try
+ {
+ (arg1)->setParameter((XMLCh const *)arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMConfiguration_setParameter) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *ptr = 0;
+ int res = SWIG_ConvertPtr(ST(2), &ptr, 0, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMConfiguration_setParameter__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMConfiguration_setParameter__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'DOMConfiguration_setParameter'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_DOMConfiguration_getParameter) {
+ {
+ XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMConfiguration_getParameter(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_getParameter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMConfiguration_getParameter");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (void *)((XERCES_CPP_NAMESPACE::DOMConfiguration const *)arg1)->getParameter((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMConfiguration_canSetParameter__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *arg3 = (void *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMConfiguration_canSetParameter(self,name,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_canSetParameter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMConfiguration_canSetParameter");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ // now check the value
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMConfiguration_canSetParameter");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+ }
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMConfiguration const *)arg1)->canSetParameter((XMLCh const *)arg2,(void const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMConfiguration_canSetParameter__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ bool arg3 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMConfiguration_canSetParameter(self,name,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_canSetParameter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMConfiguration_canSetParameter");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMConfiguration_canSetParameter" "', argument " "3"" of type '" "bool""'");
+ }
+ arg3 = static_cast< bool >(val3);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMConfiguration const *)arg1)->canSetParameter((XMLCh const *)arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMConfiguration_canSetParameter) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *ptr = 0;
+ int res = SWIG_ConvertPtr(ST(2), &ptr, 0, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMConfiguration_canSetParameter__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMConfiguration_canSetParameter__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'DOMConfiguration_canSetParameter'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_DOMConfiguration_getParameterNames) {
+ {
+ XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
+ DOMStringList *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMConfiguration_getParameterNames(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_getParameterNames" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
+ {
+ try
+ {
+ result = (DOMStringList *)((XERCES_CPP_NAMESPACE::DOMConfiguration const *)arg1)->getParameterNames();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMConfiguration) {
+ {
+ XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMConfiguration(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMConfiguration" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMStringList) {
+ {
+ XERCES_CPP_NAMESPACE::DOMStringList *arg1 = (XERCES_CPP_NAMESPACE::DOMStringList *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMStringList(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMStringList" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMStringList *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMStringList * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMStringList_item) {
+ {
+ XERCES_CPP_NAMESPACE::DOMStringList *arg1 = (XERCES_CPP_NAMESPACE::DOMStringList *) 0 ;
+ XMLSize_t arg2 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMStringList_item(self,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMStringList_item" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMStringList const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMStringList * >(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMStringList_item" "', argument " "2"" of type '" "XMLSize_t""'");
+ }
+ arg2 = static_cast< XMLSize_t >(val2);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMStringList const *)arg1)->item(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMStringList_getLength) {
+ {
+ XERCES_CPP_NAMESPACE::DOMStringList *arg1 = (XERCES_CPP_NAMESPACE::DOMStringList *) 0 ;
+ XMLSize_t result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMStringList_getLength(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMStringList_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMStringList const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMStringList * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::DOMStringList const *)arg1)->getLength();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMStringList_contains) {
+ {
+ XERCES_CPP_NAMESPACE::DOMStringList *arg1 = (XERCES_CPP_NAMESPACE::DOMStringList *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMStringList_contains(self,XMLCh const *);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMStringList_contains" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMStringList const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMStringList * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMStringList_contains");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMStringList const *)arg1)->contains((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMStringList_release) {
+ {
+ XERCES_CPP_NAMESPACE::DOMStringList *arg1 = (XERCES_CPP_NAMESPACE::DOMStringList *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMStringList_release(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMStringList_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMStringList *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMStringList * >(argp1);
+ {
+ try
+ {
+ (arg1)->release();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMImplementationLS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMImplementationLS(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMImplementationLS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationLS_createLSParser__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
+ unsigned short arg2 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::MemoryManager *arg4 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
+ XERCES_CPP_NAMESPACE::XMLGrammarPool *arg5 = (XERCES_CPP_NAMESPACE::XMLGrammarPool *) (XERCES_CPP_NAMESPACE::XMLGrammarPool *)0 ;
+ XERCES_CPP_NAMESPACE::DOMLSParser *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ unsigned short val2 ;
+ int ecode2 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ arg4 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
+ if ((items < 3) || (items > 5)) {
+ SWIG_croak("Usage: DOMImplementationLS_createLSParser(self,mode,schemaType,manager,gramPool);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMImplementationLS_createLSParser" "', argument " "2"" of type '" "unsigned short""'");
+ }
+ arg2 = static_cast< unsigned short >(val2);
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMImplementationLS_createLSParser");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ if (items > 3) {
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMImplementationLS_createLSParser" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ }
+ arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp4);
+ }
+ if (items > 4) {
+ res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DOMImplementationLS_createLSParser" "', argument " "5"" of type '" "XERCES_CPP_NAMESPACE::XMLGrammarPool *const""'");
+ }
+ arg5 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLGrammarPool * >(argp5);
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSParser *)(arg1)->createLSParser(arg2,(XMLCh const *)arg3,arg4,arg5);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ delete[] arg3;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ delete[] arg3;
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationLS_createLSParser__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
+ unsigned short arg2 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::MemoryManager *arg4 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
+ XERCES_CPP_NAMESPACE::DOMLSParser *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ unsigned short val2 ;
+ int ecode2 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ arg4 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
+ if ((items < 3) || (items > 4)) {
+ SWIG_croak("Usage: DOMImplementationLS_createLSParser(self,mode,schemaType,manager);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMImplementationLS_createLSParser" "', argument " "2"" of type '" "unsigned short""'");
+ }
+ arg2 = static_cast< unsigned short >(val2);
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMImplementationLS_createLSParser");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ if (items > 3) {
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMImplementationLS_createLSParser" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ }
+ arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp4);
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSParser *)(arg1)->createLSParser(arg2,(XMLCh const *)arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ delete[] arg3;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ delete[] arg3;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationLS_createLSParser__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
+ unsigned short arg2 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::DOMLSParser *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ unsigned short val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMImplementationLS_createLSParser(self,mode,schemaType);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMImplementationLS_createLSParser" "', argument " "2"" of type '" "unsigned short""'");
+ }
+ arg2 = static_cast< unsigned short >(val2);
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMImplementationLS_createLSParser");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSParser *)(arg1)->createLSParser(arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationLS_createLSParser) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if ((items >= 3) && (items <= 5)) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(2)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (items > 3) {
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(3), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (items > 4) {
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(4), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ }
+ }
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if ((items >= 3) && (items <= 4)) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(2)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (items > 3) {
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(3), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ }
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(2)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_3:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSParser__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSParser__SWIG_1); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSParser__SWIG_2); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'DOMImplementationLS_createLSParser'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_DOMImplementationLS_createLSSerializer) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSSerializer *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMImplementationLS_createLSSerializer(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSSerializer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSSerializer *)(arg1)->createLSSerializer();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationLS_createLSInput__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
+ XERCES_CPP_NAMESPACE::MemoryManager *arg2 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
+ XERCES_CPP_NAMESPACE::DOMLSInput *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ arg2 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
+ if ((items < 1) || (items > 2)) {
+ SWIG_croak("Usage: DOMImplementationLS_createLSInput(self,manager);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
+ if (items > 1) {
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMImplementationLS_createLSInput" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp2);
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSInput *)(arg1)->createLSInput(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationLS_createLSInput__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSInput *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMImplementationLS_createLSInput(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSInput *)(arg1)->createLSInput();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationLS_createLSInput) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if ((items >= 1) && (items <= 2)) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (items > 1) {
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ }
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 1) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSInput__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSInput__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'DOMImplementationLS_createLSInput'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_DOMImplementationLS_createLSOutput__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
+ XERCES_CPP_NAMESPACE::MemoryManager *arg2 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
+ XERCES_CPP_NAMESPACE::DOMLSOutput *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ arg2 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
+ if ((items < 1) || (items > 2)) {
+ SWIG_croak("Usage: DOMImplementationLS_createLSOutput(self,manager);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSOutput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
+ if (items > 1) {
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMImplementationLS_createLSOutput" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp2);
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSOutput *)(arg1)->createLSOutput(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationLS_createLSOutput__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSOutput *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMImplementationLS_createLSOutput(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSOutput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSOutput *)(arg1)->createLSOutput();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationLS_createLSOutput) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if ((items >= 1) && (items <= 2)) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (items > 1) {
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ }
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 1) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSOutput__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSOutput__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'DOMImplementationLS_createLSOutput'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_DOMImplementation) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMImplementation(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMImplementation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementation_hasFeature) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMImplementation_hasFeature(self,feature,version);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementation_hasFeature" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMImplementation_hasFeature");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMImplementation_hasFeature");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMImplementation const *)arg1)->hasFeature((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementation_createDocumentType) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XMLCh *arg4 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocumentType *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMImplementation_createDocumentType(self,qualifiedName,publicId,systemId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementation_createDocumentType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMImplementation_createDocumentType");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMImplementation_createDocumentType");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DOMImplementation_createDocumentType");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocumentType *)(arg1)->createDocumentType((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementation_createDocument__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocumentType *arg4 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMImplementation_createDocument(self,namespaceURI,qualifiedName,doctype);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementation_createDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMImplementation_createDocument");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMImplementation_createDocument");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMImplementation_createDocument" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType *""'");
+ }
+ arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp4);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->createDocument((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementation_getFeature) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ void *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMImplementation_getFeature(self,feature,version);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementation_getFeature" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMImplementation_getFeature");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMImplementation_getFeature");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (void *)((XERCES_CPP_NAMESPACE::DOMImplementation const *)arg1)->getFeature((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementation_createDocument__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMImplementation_createDocument(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementation_createDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->createDocument();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementation_createDocument) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 1) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 4) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(2)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(3), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementation_createDocument__SWIG_1); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementation_createDocument__SWIG_0); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'DOMImplementation_createDocument'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_DOMImplementation_getImplementation) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementation *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: DOMImplementation_getImplementation();");
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMImplementation *)XERCES_CPP_NAMESPACE::DOMImplementation::getImplementation();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMImplementationList) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationList *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationList *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMImplementationList(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMImplementationList" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationList *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationList * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationList_item) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationList *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationList *) 0 ;
+ XMLSize_t arg2 ;
+ XERCES_CPP_NAMESPACE::DOMImplementation *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMImplementationList_item(self,index);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationList_item" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationList const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationList * >(argp1);
+ ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMImplementationList_item" "', argument " "2"" of type '" "XMLSize_t""'");
+ }
+ arg2 = static_cast< XMLSize_t >(val2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMImplementation *)((XERCES_CPP_NAMESPACE::DOMImplementationList const *)arg1)->item(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationList_getLength) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationList *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationList *) 0 ;
+ XMLSize_t result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMImplementationList_getLength(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationList_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationList const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationList * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::DOMImplementationList const *)arg1)->getLength();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationList_release) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationList *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationList *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMImplementationList_release(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationList_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationList *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationList * >(argp1);
+ {
+ try
+ {
+ (arg1)->release();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMImplementationSource) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationSource *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationSource *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMImplementationSource(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMImplementationSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationSource * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationSource_getDOMImplementation) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationSource *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationSource *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMImplementation *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMImplementationSource_getDOMImplementation(self,features);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationSource_getDOMImplementation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationSource * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMImplementationSource_getDOMImplementation");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMImplementation *)((XERCES_CPP_NAMESPACE::DOMImplementationSource const *)arg1)->getDOMImplementation((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationSource_getDOMImplementationList) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationSource *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationSource *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMImplementationList *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMImplementationSource_getDOMImplementationList(self,features);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationSource_getDOMImplementationList" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationSource * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMImplementationSource_getDOMImplementationList");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMImplementationList *)((XERCES_CPP_NAMESPACE::DOMImplementationSource const *)arg1)->getDOMImplementationList((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationRegistry_getDOMImplementation) {
+ {
+ XMLCh *arg1 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMImplementation *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMImplementationRegistry_getDOMImplementation(features);");
+ }
+
+ if (ST(0) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",1,"DOMImplementationRegistry_getDOMImplementation");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMImplementation *)XERCES_CPP_NAMESPACE::DOMImplementationRegistry::getDOMImplementation((uint16_t const *)arg1);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationRegistry_getDOMImplementationList) {
+ {
+ XMLCh *arg1 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMImplementationList *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMImplementationRegistry_getDOMImplementationList(features);");
+ }
+
+ if (ST(0) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",1,"DOMImplementationRegistry_getDOMImplementationList");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMImplementationList *)XERCES_CPP_NAMESPACE::DOMImplementationRegistry::getDOMImplementationList((uint16_t const *)arg1);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0 | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMImplementationRegistry_addSource) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationSource *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationSource *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMImplementationRegistry_addSource(source);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationRegistry_addSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationSource * >(argp1);
+ {
+ try
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationRegistry::addSource(arg1);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMImplementationRegistry) {
+ {
+ XERCES_CPP_NAMESPACE::DOMImplementationRegistry *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationRegistry *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMImplementationRegistry(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMImplementationRegistry" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationRegistry *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationRegistry * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMError) {
+ {
+ XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMError(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMError_getSeverity) {
+ {
+ XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
+ short result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMError_getSeverity(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getSeverity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
+ {
+ try
+ {
+ result = (short)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getSeverity();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMError_getMessage) {
+ {
+ XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMError_getMessage(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getMessage" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getMessage();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMError_getLocation) {
+ {
+ XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLocator *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMError_getLocation(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLocator *)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getLocation();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMError_getRelatedException) {
+ {
+ XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
+ void *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMError_getRelatedException(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getRelatedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
+ {
+ try
+ {
+ result = (void *)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getRelatedException();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMError_getType) {
+ {
+ XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMError_getType(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getType();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMError_getRelatedData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
+ void *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMError_getRelatedData(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getRelatedData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
+ {
+ try
+ {
+ result = (void *)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getRelatedData();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMErrorHandler) {
+ {
+ XERCES_CPP_NAMESPACE::DOMErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::DOMErrorHandler *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMErrorHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMErrorHandler, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMErrorHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMErrorHandler * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMErrorHandler_handleError) {
+ {
+ XERCES_CPP_NAMESPACE::DOMErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::DOMErrorHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMError *arg2 = 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMErrorHandler_handleError(self,domError);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMErrorHandler, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMErrorHandler_handleError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMErrorHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMErrorHandler * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMErrorHandler_handleError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMError const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DOMErrorHandler_handleError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMError const &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp2);
+ {
+ try
+ {
+ result = (bool)(arg1)->handleError((XERCES_CPP_NAMESPACE::DOMError const &)*arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMDocument) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMDocument(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createElement) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_createElement(self,tagName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createElement" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createElement");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMElement *)(arg1)->createElement((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createDocumentFragment) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocumentFragment *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_createDocumentFragment(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createDocumentFragment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocumentFragment *)(arg1)->createDocumentFragment();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createTextNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMText *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_createTextNode(self,data);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createTextNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createTextNode");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMText *)(arg1)->createTextNode((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createComment) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMComment *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_createComment(self,data);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createComment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createComment");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMComment *)(arg1)->createComment((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createCDATASection) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMCDATASection *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_createCDATASection(self,data);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createCDATASection" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createCDATASection");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMCDATASection *)(arg1)->createCDATASection((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createProcessingInstruction) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMProcessingInstruction *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMDocument_createProcessingInstruction(self,target,data);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createProcessingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createProcessingInstruction");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMDocument_createProcessingInstruction");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *)(arg1)->createProcessingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createAttribute) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_createAttribute(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createAttribute");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->createAttribute((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createEntityReference) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMEntityReference *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_createEntityReference(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createEntityReference" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createEntityReference");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMEntityReference *)(arg1)->createEntityReference((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getDoctype) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocumentType *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_getDoctype(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getDoctype" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocumentType *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getDoctype();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getImplementation) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMImplementation *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_getImplementation(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getImplementation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMImplementation *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getImplementation();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getDocumentElement) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_getDocumentElement(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getDocumentElement" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getDocumentElement();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getElementsByTagName) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_getElementsByTagName(self,tagname);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getElementsByTagName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_getElementsByTagName");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getElementsByTagName((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_importNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ bool arg3 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ bool val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMDocument_importNode(self,importedNode,deep);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_importNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMDocument_importNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMDocument_importNode" "', argument " "3"" of type '" "bool""'");
+ }
+ arg3 = static_cast< bool >(val3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->importNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createElementNS__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMDocument_createElementNS(self,namespaceURI,qualifiedName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createElementNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createElementNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMDocument_createElementNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMElement *)(arg1)->createElementNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createAttributeNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMDocument_createAttributeNS(self,namespaceURI,qualifiedName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMDocument_createAttributeNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->createAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getElementsByTagNameNS) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMDocument_getElementsByTagNameNS(self,namespaceURI,localName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getElementsByTagNameNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_getElementsByTagNameNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMDocument_getElementsByTagNameNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getElementsByTagNameNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getElementById) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_getElementById(self,elementId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getElementById" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_getElementById");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getElementById((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getInputEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_getInputEncoding(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getInputEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getInputEncoding();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getXmlEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_getXmlEncoding(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getXmlEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getXmlEncoding();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getXmlStandalone) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_getXmlStandalone(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getXmlStandalone" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getXmlStandalone();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_setXmlStandalone) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_setXmlStandalone(self,standalone);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_setXmlStandalone" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMDocument_setXmlStandalone" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setXmlStandalone(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getXmlVersion) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_getXmlVersion(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getXmlVersion" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getXmlVersion();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_setXmlVersion) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_setXmlVersion(self,version);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_setXmlVersion" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_setXmlVersion");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setXmlVersion((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getDocumentURI) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_getDocumentURI(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getDocumentURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getDocumentURI();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_setDocumentURI) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_setDocumentURI(self,documentURI);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_setDocumentURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_setDocumentURI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setDocumentURI((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getStrictErrorChecking) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_getStrictErrorChecking(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getStrictErrorChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getStrictErrorChecking();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_setStrictErrorChecking) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_setStrictErrorChecking(self,strictErrorChecking);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_setStrictErrorChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMDocument_setStrictErrorChecking" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setStrictErrorChecking(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_renameNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XMLCh *arg4 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMDocument_renameNode(self,n,namespaceURI,qualifiedName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_renameNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMDocument_renameNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMDocument_renameNode");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DOMDocument_renameNode");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->renameNode(arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_adoptNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_adoptNode(self,source);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_adoptNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMDocument_adoptNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->adoptNode(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_normalizeDocument) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_normalizeDocument(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_normalizeDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ (arg1)->normalizeDocument();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_getDOMConfig) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMConfiguration *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMDocument_getDOMConfig(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getDOMConfig" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMConfiguration *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getDOMConfig();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createEntity) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMEntity *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_createEntity(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createEntity");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMEntity *)(arg1)->createEntity((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createDocumentType__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocumentType *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_createDocumentType(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createDocumentType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createDocumentType");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocumentType *)(arg1)->createDocumentType((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createDocumentType__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XMLCh *arg4 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocumentType *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMDocument_createDocumentType(self,qName,XMLCh const *,XMLCh const *);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createDocumentType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createDocumentType");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMDocument_createDocumentType");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DOMDocument_createDocumentType");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocumentType *)(arg1)->createDocumentType((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createDocumentType) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 4) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(2)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(3)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMDocument_createDocumentType__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMDocument_createDocumentType__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'DOMDocument_createDocumentType'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_DOMDocument_createNotation) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNotation *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMDocument_createNotation(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createNotation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createNotation");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNotation *)(arg1)->createNotation((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createElementNS__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ XMLSSize_t arg4 ;
+ XMLSSize_t arg5 ;
+ XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val4 ;
+ int ecode4 = 0 ;
+ size_t val5 ;
+ int ecode5 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: DOMDocument_createElementNS(self,namespaceURI,qualifiedName,lineNum,columnNum);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createElementNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createElementNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMDocument_createElementNS");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMDocument_createElementNS" "', argument " "4"" of type '" "XMLSSize_t""'");
+ }
+ arg4 = static_cast< XMLSSize_t >(val4);
+ ecode5 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DOMDocument_createElementNS" "', argument " "5"" of type '" "XMLSSize_t""'");
+ }
+ arg5 = static_cast< XMLSSize_t >(val5);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMElement *)(arg1)->createElementNS((XMLCh const *)arg2,(XMLCh const *)arg3,arg4,arg5);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMDocument_createElementNS) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(2)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 5) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(2)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMDocument_createElementNS__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMDocument_createElementNS__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'DOMDocument_createElementNS'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_DOMLocator) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMLocator(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLocator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLocator_getLineNumber) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
+ XMLSSize_t result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLocator_getLineNumber(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getLineNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getLineNumber();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLocator_getColumnNumber) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
+ XMLSSize_t result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLocator_getColumnNumber(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getColumnNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getColumnNumber();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLocator_getByteOffset) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
+ XMLSSize_t result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLocator_getByteOffset(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getByteOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getByteOffset();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLocator_getUtf16Offset) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
+ XMLSSize_t result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLocator_getUtf16Offset(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getUtf16Offset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getUtf16Offset();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLocator_getRelatedNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLocator_getRelatedNode(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getRelatedNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getRelatedNode();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLocator_getURI) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLocator_getURI(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getURI();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMLSResourceResolver) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSResourceResolver *arg1 = (XERCES_CPP_NAMESPACE::DOMLSResourceResolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMLSResourceResolver(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSResourceResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSResourceResolver *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSResourceResolver * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSResourceResolver_resolveResource) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSResourceResolver *arg1 = (XERCES_CPP_NAMESPACE::DOMLSResourceResolver *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg6 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::DOMLSInput *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 6) || (items > 6)) {
+ SWIG_croak("Usage: DOMLSResourceResolver_resolveResource(self,resourceType,namespaceUri,publicId,systemId,baseURI);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSResourceResolver_resolveResource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSResourceResolver *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSResourceResolver * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSResourceResolver_resolveResource");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMLSResourceResolver_resolveResource");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DOMLSResourceResolver_resolveResource");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
+ }
+
+
+ if (ST(4) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",5,"DOMLSResourceResolver_resolveResource");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
+ }
+
+
+ if (ST(5) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",6,"DOMLSResourceResolver_resolveResource");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg6 = UTF8_TRANSCODER->Perl2XMLString(ST(5));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSInput *)(arg1)->resolveResource((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5,(XMLCh const *)arg6);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+
+ delete[] arg5;
+
+
+ delete[] arg6;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+
+ delete[] arg5;
+
+
+ delete[] arg6;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMLSInput) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMLSInput(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_getStringData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSInput_getStringData(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getStringData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getStringData();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_getByteStream) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XERCES_CPP_NAMESPACE::InputSource *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSInput_getByteStream(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::InputSource *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getByteStream();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_getEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSInput_getEncoding(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getEncoding();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_getPublicId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSInput_getPublicId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getPublicId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_getSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSInput_getSystemId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getSystemId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_getBaseURI) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSInput_getBaseURI(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getBaseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getBaseURI();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_setStringData) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSInput_setStringData(self,data);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setStringData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSInput_setStringData");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setStringData((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_setByteStream) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XERCES_CPP_NAMESPACE::InputSource *arg2 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSInput_setByteStream(self,stream);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSInput_setByteStream" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
+ {
+ try
+ {
+ (arg1)->setByteStream(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_setEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSInput_setEncoding(self,encodingStr);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSInput_setEncoding");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setEncoding((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_setPublicId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSInput_setPublicId(self,publicId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSInput_setPublicId");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setPublicId((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_setSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSInput_setSystemId(self,systemId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSInput_setSystemId");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setSystemId((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_setBaseURI) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSInput_setBaseURI(self,baseURI);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setBaseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSInput_setBaseURI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setBaseURI((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_setIssueFatalErrorIfNotFound) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSInput_setIssueFatalErrorIfNotFound(self,flag);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMLSInput_setIssueFatalErrorIfNotFound" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setIssueFatalErrorIfNotFound(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_getIssueFatalErrorIfNotFound) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSInput_getIssueFatalErrorIfNotFound(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getIssueFatalErrorIfNotFound();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSInput_release) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSInput_release(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ {
+ try
+ {
+ (arg1)->release();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_Wrapper4InputSource) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) (XERCES_CPP_NAMESPACE::InputSource *)0 ;
+ bool arg2 ;
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ arg2 = true;
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_Wrapper4InputSource(inputSource);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wrapper4InputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource *const""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *)new XERCES_CPP_NAMESPACE::Wrapper4InputSource(arg1,arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_Wrapper4InputSource) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_Wrapper4InputSource(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Wrapper4InputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_getStringData) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4InputSource_getStringData(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getStringData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getStringData();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_getByteStream) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XERCES_CPP_NAMESPACE::InputSource *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4InputSource_getByteStream(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::InputSource *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getByteStream();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_getEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4InputSource_getEncoding(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getEncoding();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_getPublicId) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4InputSource_getPublicId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getPublicId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_getSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4InputSource_getSystemId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getSystemId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_getBaseURI) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4InputSource_getBaseURI(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getBaseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getBaseURI();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_getIssueFatalErrorIfNotFound) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4InputSource_getIssueFatalErrorIfNotFound(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getIssueFatalErrorIfNotFound();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_setStringData) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Wrapper4InputSource_setStringData(self,data);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setStringData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"Wrapper4InputSource_setStringData");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setStringData((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_setByteStream) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XERCES_CPP_NAMESPACE::InputSource *arg2 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Wrapper4InputSource_setByteStream(self,stream);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wrapper4InputSource_setByteStream" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
+ {
+ try
+ {
+ (arg1)->setByteStream(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_setEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Wrapper4InputSource_setEncoding(self,encodingStr);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"Wrapper4InputSource_setEncoding");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setEncoding((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_setPublicId) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Wrapper4InputSource_setPublicId(self,publicId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"Wrapper4InputSource_setPublicId");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setPublicId((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_setSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Wrapper4InputSource_setSystemId(self,systemId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"Wrapper4InputSource_setSystemId");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setSystemId((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_setBaseURI) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Wrapper4InputSource_setBaseURI(self,baseURI);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setBaseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"Wrapper4InputSource_setBaseURI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setBaseURI((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_setIssueFatalErrorIfNotFound) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Wrapper4InputSource_setIssueFatalErrorIfNotFound(self,flag);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wrapper4InputSource_setIssueFatalErrorIfNotFound" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setIssueFatalErrorIfNotFound(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4InputSource_release) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4InputSource_release(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
+ {
+ try
+ {
+ (arg1)->release();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_Wrapper4DOMLSInput__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) (XERCES_CPP_NAMESPACE::DOMLSInput *)0 ;
+ XERCES_CPP_NAMESPACE::DOMLSResourceResolver *arg2 = (XERCES_CPP_NAMESPACE::DOMLSResourceResolver *) 0 ;
+ bool arg3 ;
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ arg3 = true;
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: new_Wrapper4DOMLSInput(inputSource,entityResolver);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wrapper4DOMLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *const""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Wrapper4DOMLSInput" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSResourceResolver *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSResourceResolver * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *)new XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput(arg1,arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_Wrapper4DOMLSInput__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) (XERCES_CPP_NAMESPACE::DOMLSInput *)0 ;
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_Wrapper4DOMLSInput(inputSource);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wrapper4DOMLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *const""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *)new XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput(arg1);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_Wrapper4DOMLSInput) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 1) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_Wrapper4DOMLSInput__SWIG_1); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_Wrapper4DOMLSInput__SWIG_0); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_Wrapper4DOMLSInput'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_Wrapper4DOMLSInput) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_Wrapper4DOMLSInput(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Wrapper4DOMLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4DOMLSInput_makeStream) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
+ XERCES_CPP_NAMESPACE::BinInputStream *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4DOMLSInput_makeStream(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_makeStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::BinInputStream *)((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *)arg1)->makeStream();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__BinInputStream, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4DOMLSInput_getEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4DOMLSInput_getEncoding(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_getEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *)arg1)->getEncoding();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4DOMLSInput_getPublicId) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4DOMLSInput_getPublicId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *)arg1)->getPublicId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4DOMLSInput_getSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4DOMLSInput_getSystemId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *)arg1)->getSystemId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *)arg1)->getIssueFatalErrorIfNotFound();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4DOMLSInput_setEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Wrapper4DOMLSInput_setEncoding(self,encodingStr);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_setEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"Wrapper4DOMLSInput_setEncoding");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setEncoding((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4DOMLSInput_setPublicId) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Wrapper4DOMLSInput_setPublicId(self,publicId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_setPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"Wrapper4DOMLSInput_setPublicId");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setPublicId((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4DOMLSInput_setSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Wrapper4DOMLSInput_setSystemId(self,systemId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_setSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"Wrapper4DOMLSInput_setSystemId");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setSystemId((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound) {
+ {
+ XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound(self,flag);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setIssueFatalErrorIfNotFound(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMLSParser) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMLSParser(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_getDomConfig) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMConfiguration *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSParser_getDomConfig(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getDomConfig" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMConfiguration *)(arg1)->getDomConfig();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_getAsync) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSParser_getAsync(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getAsync" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getAsync();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_getBusy) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSParser_getBusy(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getBusy" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getBusy();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_setFilter) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSParserFilter *arg2 = (XERCES_CPP_NAMESPACE::DOMLSParserFilter *) (XERCES_CPP_NAMESPACE::DOMLSParserFilter *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSParser_setFilter(self,filter);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_setFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParserFilter, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSParser_setFilter" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParserFilter *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParserFilter * >(argp2);
+ {
+ try
+ {
+ (arg1)->setFilter(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_parse) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg2 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSParser_parse(self,source);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSParser_parse" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->parse((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_parseURI) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSParser_parseURI(self,uri);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_parseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSParser_parseURI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->parseURI((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_parseWithContext) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg2 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg3 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ unsigned short arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ unsigned short val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMLSParser_parseWithContext(self,source,contextNode,action);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_parseWithContext" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSParser_parseWithContext" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMLSParser_parseWithContext" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp3);
+ ecode4 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMLSParser_parseWithContext" "', argument " "4"" of type '" "unsigned short""'");
+ }
+ arg4 = static_cast< unsigned short >(val4);
+ {
+ try
+ {
+ (arg1)->parseWithContext((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg2,arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_abort) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSParser_abort(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_abort" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ {
+ try
+ {
+ (arg1)->abort();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_release) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSParser_release(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ {
+ try
+ {
+ (arg1)->release();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_resetDocumentPool) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSParser_resetDocumentPool(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_resetDocumentPool" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ {
+ try
+ {
+ (arg1)->resetDocumentPool();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_loadGrammar__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg2 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ short arg3 ;
+ bool arg4 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ short val3 ;
+ int ecode3 = 0 ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMLSParser_loadGrammar(self,source,grammarType,toCache);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp2);
+ ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMLSParser_loadGrammar" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = static_cast< short >(val3);
+ ecode4 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMLSParser_loadGrammar" "', argument " "4"" of type '" "bool""'");
+ }
+ arg4 = static_cast< bool >(val4);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg2,arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_loadGrammar__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSInput *arg2 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
+ short arg3 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ short val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMLSParser_loadGrammar(self,source,grammarType);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp2);
+ ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMLSParser_loadGrammar" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = static_cast< short >(val3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_loadGrammar__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ short arg3 ;
+ bool arg4 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ short val3 ;
+ int ecode3 = 0 ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DOMLSParser_loadGrammar(self,systemId,grammarType,toCache);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSParser_loadGrammar");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMLSParser_loadGrammar" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = static_cast< short >(val3);
+ ecode4 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMLSParser_loadGrammar" "', argument " "4"" of type '" "bool""'");
+ }
+ arg4 = static_cast< bool >(val4);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_loadGrammar__SWIG_3) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ short arg3 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ short val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMLSParser_loadGrammar(self,systemId,grammarType);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSParser_loadGrammar");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMLSParser_loadGrammar" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = static_cast< short >(val3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_loadGrammar) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ if (items == 4) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_3:
+
+ if (items == 4) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 4;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_4:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMLSParser_loadGrammar__SWIG_1); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMLSParser_loadGrammar__SWIG_3); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMLSParser_loadGrammar__SWIG_0); return;
+ case 4:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMLSParser_loadGrammar__SWIG_2); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'DOMLSParser_loadGrammar'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_DOMLSParser_getGrammar) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSParser_getGrammar(self,nameSpaceKey);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSParser_getGrammar");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getGrammar((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_getRootGrammar) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSParser_getRootGrammar(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getRootGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getRootGrammar();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_getURIText) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ unsigned int arg2 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSParser_getURIText(self,uriId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getURIText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMLSParser_getURIText" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getURIText(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_resetCachedGrammarPool) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSParser_resetCachedGrammarPool(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_resetCachedGrammarPool" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ {
+ try
+ {
+ (arg1)->resetCachedGrammarPool();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSParser_getSrcOffset) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
+ unsigned int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSParser_getSrcOffset(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getSrcOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
+ {
+ try
+ {
+ result = (unsigned int)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getSrcOffset();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMLSOutput) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMLSOutput(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSOutput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSOutput_getByteStream) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatTarget *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSOutput_getByteStream(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_getByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLFormatTarget *)((XERCES_CPP_NAMESPACE::DOMLSOutput const *)arg1)->getByteStream();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSOutput_getEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSOutput_getEncoding(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_getEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSOutput const *)arg1)->getEncoding();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSOutput_getSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSOutput_getSystemId(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSOutput const *)arg1)->getSystemId();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSOutput_setByteStream) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatTarget *arg2 = (XERCES_CPP_NAMESPACE::XMLFormatTarget *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSOutput_setByteStream(self,stream);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_setByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSOutput_setByteStream" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatTarget *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatTarget * >(argp2);
+ {
+ try
+ {
+ (arg1)->setByteStream(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSOutput_setEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSOutput_setEncoding(self,encodingStr);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_setEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSOutput_setEncoding");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setEncoding((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSOutput_setSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSOutput_setSystemId(self,systemId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_setSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSOutput_setSystemId");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setSystemId((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSOutput_release) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSOutput_release(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
+ {
+ try
+ {
+ (arg1)->release();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_StdOutFormatTarget) {
+ {
+ XERCES_CPP_NAMESPACE::StdOutFormatTarget *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_StdOutFormatTarget();");
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::StdOutFormatTarget *)new XERCES_CPP_NAMESPACE::StdOutFormatTarget();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_StdOutFormatTarget) {
+ {
+ XERCES_CPP_NAMESPACE::StdOutFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::StdOutFormatTarget *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_StdOutFormatTarget(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StdOutFormatTarget" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::StdOutFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::StdOutFormatTarget * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_StdOutFormatTarget_writeChars) {
+ {
+ XERCES_CPP_NAMESPACE::StdOutFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::StdOutFormatTarget *) 0 ;
+ XMLByte *arg2 = (XMLByte *) (XMLByte *)0 ;
+ unsigned int arg3 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg4 = (XERCES_CPP_NAMESPACE::XMLFormatter *) (XERCES_CPP_NAMESPACE::XMLFormatter *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: StdOutFormatTarget_writeChars(self,toWrite,count,formatter);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdOutFormatTarget_writeChars" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::StdOutFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::StdOutFormatTarget * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdOutFormatTarget_writeChars" "', argument " "2"" of type '" "XMLByte const *const""'");
+ }
+ arg2 = reinterpret_cast< XMLByte * >(argp2);
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StdOutFormatTarget_writeChars" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StdOutFormatTarget_writeChars" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *const""'");
+ }
+ arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp4);
+ {
+ try
+ {
+ (arg1)->writeChars((XMLByte const *)arg2,arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_StdOutFormatTarget_flush) {
+ {
+ XERCES_CPP_NAMESPACE::StdOutFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::StdOutFormatTarget *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: StdOutFormatTarget_flush(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdOutFormatTarget_flush" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::StdOutFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::StdOutFormatTarget * >(argp1);
+ {
+ try
+ {
+ (arg1)->flush();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_LocalFileFormatTarget) {
+ {
+ XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::LocalFileFormatTarget *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_LocalFileFormatTarget(XMLCh const *const);");
+ }
+
+ if (ST(0) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",1,"new_LocalFileFormatTarget");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::LocalFileFormatTarget *)new XERCES_CPP_NAMESPACE::LocalFileFormatTarget((XMLCh const *)arg1);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_LocalFileFormatTarget) {
+ {
+ XERCES_CPP_NAMESPACE::LocalFileFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::LocalFileFormatTarget *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_LocalFileFormatTarget(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalFileFormatTarget" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LocalFileFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LocalFileFormatTarget * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_LocalFileFormatTarget_writeChars) {
+ {
+ XERCES_CPP_NAMESPACE::LocalFileFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::LocalFileFormatTarget *) 0 ;
+ XMLByte *arg2 = (XMLByte *) (XMLByte *)0 ;
+ unsigned int arg3 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg4 = (XERCES_CPP_NAMESPACE::XMLFormatter *) (XERCES_CPP_NAMESPACE::XMLFormatter *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: LocalFileFormatTarget_writeChars(self,toWrite,count,formatter);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalFileFormatTarget_writeChars" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LocalFileFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LocalFileFormatTarget * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalFileFormatTarget_writeChars" "', argument " "2"" of type '" "XMLByte const *const""'");
+ }
+ arg2 = reinterpret_cast< XMLByte * >(argp2);
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LocalFileFormatTarget_writeChars" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LocalFileFormatTarget_writeChars" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *const""'");
+ }
+ arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp4);
+ {
+ try
+ {
+ (arg1)->writeChars((XMLByte const *)arg2,arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_LocalFileFormatTarget_flush) {
+ {
+ XERCES_CPP_NAMESPACE::LocalFileFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::LocalFileFormatTarget *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: LocalFileFormatTarget_flush(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalFileFormatTarget_flush" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LocalFileFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LocalFileFormatTarget * >(argp1);
+ {
+ try
+ {
+ (arg1)->flush();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_MemBufFormatTarget__SWIG_0) {
+ {
+ int arg1 ;
+ XERCES_CPP_NAMESPACE::MemBufFormatTarget *result = 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_MemBufFormatTarget(initCapacity);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MemBufFormatTarget" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = static_cast< int >(val1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *)new XERCES_CPP_NAMESPACE::MemBufFormatTarget(arg1);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_MemBufFormatTarget__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::MemBufFormatTarget *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_MemBufFormatTarget();");
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *)new XERCES_CPP_NAMESPACE::MemBufFormatTarget();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_MemBufFormatTarget) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 0) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ if (items == 1) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_MemBufFormatTarget__SWIG_1); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_MemBufFormatTarget__SWIG_0); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_MemBufFormatTarget'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_MemBufFormatTarget) {
+ {
+ XERCES_CPP_NAMESPACE::MemBufFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_MemBufFormatTarget(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MemBufFormatTarget" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufFormatTarget * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_MemBufFormatTarget_writeChars) {
+ {
+ XERCES_CPP_NAMESPACE::MemBufFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *) 0 ;
+ XMLByte *arg2 = (XMLByte *) (XMLByte *)0 ;
+ unsigned int arg3 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg4 = (XERCES_CPP_NAMESPACE::XMLFormatter *) (XERCES_CPP_NAMESPACE::XMLFormatter *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: MemBufFormatTarget_writeChars(self,toWrite,count,formatter);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemBufFormatTarget_writeChars" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufFormatTarget * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemBufFormatTarget_writeChars" "', argument " "2"" of type '" "XMLByte const *const""'");
+ }
+ arg2 = reinterpret_cast< XMLByte * >(argp2);
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemBufFormatTarget_writeChars" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MemBufFormatTarget_writeChars" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *const""'");
+ }
+ arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp4);
+ {
+ try
+ {
+ (arg1)->writeChars((XMLByte const *)arg2,arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_MemBufFormatTarget_getRawBuffer) {
+ {
+ XERCES_CPP_NAMESPACE::MemBufFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *) 0 ;
+ XMLByte *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: MemBufFormatTarget_getRawBuffer(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemBufFormatTarget_getRawBuffer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufFormatTarget const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufFormatTarget * >(argp1);
+ {
+ try
+ {
+ result = (XMLByte *)((XERCES_CPP_NAMESPACE::MemBufFormatTarget const *)arg1)->getRawBuffer();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_FromCharPtr((char*)result); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_MemBufFormatTarget_getLen) {
+ {
+ XERCES_CPP_NAMESPACE::MemBufFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *) 0 ;
+ unsigned int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: MemBufFormatTarget_getLen(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemBufFormatTarget_getLen" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufFormatTarget const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufFormatTarget * >(argp1);
+ {
+ try
+ {
+ result = (unsigned int)((XERCES_CPP_NAMESPACE::MemBufFormatTarget const *)arg1)->getLen();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_MemBufFormatTarget_reset) {
+ {
+ XERCES_CPP_NAMESPACE::MemBufFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: MemBufFormatTarget_reset(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemBufFormatTarget_reset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufFormatTarget * >(argp1);
+ {
+ try
+ {
+ (arg1)->reset();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMLSException__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSException *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_DOMLSException();");
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSException *)new XERCES_CPP_NAMESPACE::DOMLSException();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMLSException__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode arg1 ;
+ short arg2 ;
+ XERCES_CPP_NAMESPACE::MemoryManager *arg3 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
+ XERCES_CPP_NAMESPACE::DOMLSException *result = 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ short val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: new_DOMLSException(code,messageCode,memoryManager);");
+ }
+ ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMLSException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode""'");
+ }
+ arg1 = static_cast< XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode >(val1);
+ ecode2 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DOMLSException" "', argument " "2"" of type '" "short""'");
+ }
+ arg2 = static_cast< short >(val2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DOMLSException" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSException *)new XERCES_CPP_NAMESPACE::DOMLSException(arg1,arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMLSException__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSException *arg1 = 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSException *result = 0 ;
+ void *argp1 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_DOMLSException(other);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DOMLSException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException const &""'");
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DOMLSException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException const &""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMLSException *)new XERCES_CPP_NAMESPACE::DOMLSException((XERCES_CPP_NAMESPACE::DOMLSException const &)*arg1);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_DOMLSException) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 0) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ if (items == 1) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_3:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMLSException__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMLSException__SWIG_2); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMLSException__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_DOMLSException'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_DOMLSException) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMLSException(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSException_getMessage) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSException_getMessage(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSException_getMessage" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSException const *)arg1)->getMessage();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSException_code_set) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSException_code_set(self,code);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSException_code_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMLSException_code_set" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode >(val2);
+ if (arg1) (arg1)->code = arg2;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSException_code_get) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSException_code_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSException_code_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
+ result = (XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode) ((arg1)->code);
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSException_msg_set) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
+ XMLCh *arg2 = (XMLCh *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSException_msg_set(self,msg);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSException_msg_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSException_msg_set");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ if (arg1) (arg1)->msg = (XMLCh const *)arg2;
+
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSException_msg_get) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSException_msg_get(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSException_msg_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
+ result = (XMLCh *) ((arg1)->msg);
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMLSSerializer) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMLSSerializer(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSSerializer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSSerializer_getDomConfig) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMConfiguration *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSSerializer_getDomConfig(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_getDomConfig" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMConfiguration *)(arg1)->getDomConfig();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSSerializer_setNewLine) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSSerializer_setNewLine(self,newLine);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_setNewLine" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DOMLSSerializer_setNewLine");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setNewLine((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSSerializer_setFilter) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
+ DOMLSSerializerFilter *arg2 = (DOMLSSerializerFilter *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSSerializer_setFilter(self,filter);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_setFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSSerializer_setFilter" "', argument " "2"" of type '" "DOMLSSerializerFilter *""'");
+ }
+ arg2 = reinterpret_cast< DOMLSSerializerFilter * >(argp2);
+ {
+ try
+ {
+ (arg1)->setFilter(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSSerializer_getNewLine) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSSerializer_getNewLine(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_getNewLine" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSSerializer const *)arg1)->getNewLine();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSSerializer_write) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMLSOutput *arg3 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) (XERCES_CPP_NAMESPACE::DOMLSOutput *)0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMLSSerializer_write(self,nodeToWrite,destination);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_write" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSSerializer_write" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMLSSerializer_write" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *const""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp3);
+ {
+ try
+ {
+ result = (bool)(arg1)->write((XERCES_CPP_NAMESPACE::DOMNode const *)arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSSerializer_writeToURI) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *arg3 = (XMLCh *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DOMLSSerializer_writeToURI(self,nodeToWrite,uri);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_writeToURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSSerializer_writeToURI" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DOMLSSerializer_writeToURI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ try
+ {
+ result = (bool)(arg1)->writeToURI((XERCES_CPP_NAMESPACE::DOMNode const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSSerializer_writeToString) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSSerializer_writeToString(self,nodeToWrite);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_writeToString" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSSerializer_writeToString" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (XMLCh *)(arg1)->writeToString((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSSerializer_release) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSSerializer_release(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
+ {
+ try
+ {
+ (arg1)->release();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_DOMLSSerializerFilter) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DOMLSSerializerFilter(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSSerializerFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializerFilter * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSSerializerFilter_acceptNode) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ short result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DOMLSSerializerFilter_acceptNode(self,node);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializerFilter_acceptNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializerFilter const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializerFilter * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSSerializerFilter_acceptNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (short)((XERCES_CPP_NAMESPACE::DOMLSSerializerFilter const *)arg1)->acceptNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_DOMLSSerializerFilter_getWhatToShow) {
+ {
+ XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *) 0 ;
+ unsigned long result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DOMLSSerializerFilter_getWhatToShow(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializerFilter_getWhatToShow" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializerFilter const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializerFilter * >(argp1);
+ {
+ try
+ {
+ result = (unsigned long)((XERCES_CPP_NAMESPACE::DOMLSSerializerFilter const *)arg1)->getWhatToShow();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(static_cast< unsigned long >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_AbstractDOMParser) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_AbstractDOMParser(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AbstractDOMParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_reset) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_reset(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_reset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ (arg1)->reset();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_adoptDocument) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_adoptDocument(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_adoptDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->adoptDocument();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getDocument) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getDocument(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->getDocument();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getValidator) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLValidator *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getValidator(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getValidator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ {
+ XERCES_CPP_NAMESPACE::XMLValidator const &_result_ref = ((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getValidator();
+ result = (XERCES_CPP_NAMESPACE::XMLValidator *) &_result_ref;
+ }
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getValidationScheme) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::AbstractDOMParser::ValSchemes result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getValidationScheme(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getValidationScheme" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::AbstractDOMParser::ValSchemes)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getValidationScheme();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getDoSchema) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getDoSchema(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getDoSchema" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getDoSchema();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getValidationSchemaFullChecking) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getValidationSchemaFullChecking(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getValidationSchemaFullChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getValidationSchemaFullChecking();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getIdentityConstraintChecking) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getIdentityConstraintChecking(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getIdentityConstraintChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getIdentityConstraintChecking();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getErrorCount) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getErrorCount(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getErrorCount" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (int)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getErrorCount();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getDoNamespaces) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getDoNamespaces(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getDoNamespaces" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getDoNamespaces();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getExitOnFirstFatalError) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getExitOnFirstFatalError(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getExitOnFirstFatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getExitOnFirstFatalError();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getValidationConstraintFatal) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getValidationConstraintFatal(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getValidationConstraintFatal" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getValidationConstraintFatal();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getCreateEntityReferenceNodes) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getCreateEntityReferenceNodes(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getCreateEntityReferenceNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getCreateEntityReferenceNodes();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getIncludeIgnorableWhitespace) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getIncludeIgnorableWhitespace(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getIncludeIgnorableWhitespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getIncludeIgnorableWhitespace();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getExternalSchemaLocation) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getExternalSchemaLocation(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getExternalSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getExternalSchemaLocation();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getExternalNoNamespaceSchemaLocation) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getExternalNoNamespaceSchemaLocation(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getExternalNoNamespaceSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getExternalNoNamespaceSchemaLocation();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getSecurityManager) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ SecurityManager *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getSecurityManager(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getSecurityManager" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (SecurityManager *)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getSecurityManager();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SecurityManager, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getLoadExternalDTD) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getLoadExternalDTD(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getLoadExternalDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getLoadExternalDTD();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getCreateCommentNodes) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getCreateCommentNodes(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getCreateCommentNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getCreateCommentNodes();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getCalculateSrcOfs) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getCalculateSrcOfs(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getCalculateSrcOfs" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getCalculateSrcOfs();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getStandardUriConformant) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getStandardUriConformant(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getStandardUriConformant" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getStandardUriConformant();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getPSVIHandler) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::PSVIHandler *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getPSVIHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getPSVIHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::PSVIHandler *)(arg1)->getPSVIHandler();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getCreateSchemaInfo) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getCreateSchemaInfo(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getCreateSchemaInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getCreateSchemaInfo();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getGenerateSyntheticAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getGenerateSyntheticAnnotations(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getGenerateSyntheticAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getGenerateSyntheticAnnotations();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getValidateAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getValidateAnnotations(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getValidateAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getValidateAnnotations();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getIgnoreAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getIgnoreAnnotations(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getIgnoreAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getIgnoreAnnotations();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getDisableDefaultEntityResolution) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getDisableDefaultEntityResolution(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getDisableDefaultEntityResolution" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getDisableDefaultEntityResolution();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_getSkipDTDValidation) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: AbstractDOMParser_getSkipDTDValidation(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getSkipDTDValidation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getSkipDTDValidation();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setGenerateSyntheticAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setGenerateSyntheticAnnotations(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setGenerateSyntheticAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setGenerateSyntheticAnnotations" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setGenerateSyntheticAnnotations(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setValidateAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setValidateAnnotations(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setValidateAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setValidateAnnotations" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setValidateAnnotations(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setDoNamespaces) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setDoNamespaces(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setDoNamespaces" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setDoNamespaces" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setDoNamespaces(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setExitOnFirstFatalError) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setExitOnFirstFatalError(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setExitOnFirstFatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setExitOnFirstFatalError" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setExitOnFirstFatalError(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setValidationConstraintFatal) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setValidationConstraintFatal(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setValidationConstraintFatal" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setValidationConstraintFatal" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setValidationConstraintFatal(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setCreateEntityReferenceNodes) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setCreateEntityReferenceNodes(self,create);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setCreateEntityReferenceNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setCreateEntityReferenceNodes" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setCreateEntityReferenceNodes(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setIncludeIgnorableWhitespace) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setIncludeIgnorableWhitespace(self,include);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setIncludeIgnorableWhitespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setIncludeIgnorableWhitespace" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setIncludeIgnorableWhitespace(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setValidationScheme) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::AbstractDOMParser::ValSchemes arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setValidationScheme(self,newScheme);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setValidationScheme" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setValidationScheme" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser::ValSchemes""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser::ValSchemes >(val2);
+ {
+ try
+ {
+ (arg1)->setValidationScheme(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setDoSchema) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setDoSchema(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setDoSchema" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setDoSchema" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setDoSchema(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setValidationSchemaFullChecking) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setValidationSchemaFullChecking(self,schemaFullChecking);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setValidationSchemaFullChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setValidationSchemaFullChecking" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setValidationSchemaFullChecking(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setIdentityConstraintChecking) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setIdentityConstraintChecking(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setIdentityConstraintChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setIdentityConstraintChecking" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setIdentityConstraintChecking(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setExternalSchemaLocation) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setExternalSchemaLocation(self,schemaLocation);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setExternalSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_setExternalSchemaLocation");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setExternalSchemaLocation((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setExternalNoNamespaceSchemaLocation) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setExternalNoNamespaceSchemaLocation(self,noNamespaceSchemaLocation);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setExternalNoNamespaceSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_setExternalNoNamespaceSchemaLocation");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->setExternalNoNamespaceSchemaLocation((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setSecurityManager) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ SecurityManager *arg2 = (SecurityManager *) (SecurityManager *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setSecurityManager(self,securityManager);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setSecurityManager" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_SecurityManager, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_setSecurityManager" "', argument " "2"" of type '" "SecurityManager *const""'");
+ }
+ arg2 = reinterpret_cast< SecurityManager * >(argp2);
+ {
+ try
+ {
+ (arg1)->setSecurityManager(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setLoadExternalDTD) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setLoadExternalDTD(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setLoadExternalDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setLoadExternalDTD" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setLoadExternalDTD(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setCreateCommentNodes) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setCreateCommentNodes(self,create);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setCreateCommentNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setCreateCommentNodes" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setCreateCommentNodes(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setCalculateSrcOfs) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setCalculateSrcOfs(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setCalculateSrcOfs" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setCalculateSrcOfs" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setCalculateSrcOfs(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setStandardUriConformant) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setStandardUriConformant(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setStandardUriConformant" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setStandardUriConformant" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setStandardUriConformant(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_useScanner) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_useScanner(self,scannerName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_useScanner" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_useScanner");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->useScanner((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_useImplementation) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_useImplementation(self,implementationFeatures);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_useImplementation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_useImplementation");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->useImplementation((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setPSVIHandler) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::PSVIHandler *arg2 = (XERCES_CPP_NAMESPACE::PSVIHandler *) (XERCES_CPP_NAMESPACE::PSVIHandler *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setPSVIHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setPSVIHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_setPSVIHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::PSVIHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::PSVIHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setPSVIHandler(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setCreateSchemaInfo) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setCreateSchemaInfo(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setCreateSchemaInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setCreateSchemaInfo" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setCreateSchemaInfo(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setIgnoreAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setIgnoreAnnotations(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setIgnoreAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setIgnoreAnnotations" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setIgnoreAnnotations(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setDisableDefaultEntityResolution) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setDisableDefaultEntityResolution(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setDisableDefaultEntityResolution" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setDisableDefaultEntityResolution" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setDisableDefaultEntityResolution(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_setSkipDTDValidation) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_setSkipDTDValidation(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setSkipDTDValidation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setSkipDTDValidation" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setSkipDTDValidation(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_parse__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::InputSource *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_parse(self,source);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_parse" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parse" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
+ {
+ try
+ {
+ (arg1)->parse((XERCES_CPP_NAMESPACE::InputSource const &)*arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_parse__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_parse(self,systemId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_parse");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ (arg1)->parse((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_parse) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AbstractDOMParser_parse__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AbstractDOMParser_parse__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'AbstractDOMParser_parse'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_AbstractDOMParser_parseFirst__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::XMLPScanToken *arg3 = 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: AbstractDOMParser_parseFirst(self,systemId,toFill);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_parseFirst");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp3);
+ {
+ try
+ {
+ result = (bool)(arg1)->parseFirst((XMLCh const *)arg2,*arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_parseFirst__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ char *arg2 = (char *) (char *)0 ;
+ XERCES_CPP_NAMESPACE::XMLPScanToken *arg3 = 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: AbstractDOMParser_parseFirst(self,systemId,toFill);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_parseFirst" "', argument " "2"" of type '" "char const *const""'");
+ }
+ arg2 = reinterpret_cast< char * >(buf2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp3);
+ {
+ try
+ {
+ result = (bool)(arg1)->parseFirst((char const *)arg2,*arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+
+ XSRETURN(argvi);
+ fail:
+
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_parseFirst__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::InputSource *arg2 = 0 ;
+ XERCES_CPP_NAMESPACE::XMLPScanToken *arg3 = 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: AbstractDOMParser_parseFirst(self,source,toFill);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_parseFirst" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseFirst" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
+ res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp3);
+ {
+ try
+ {
+ result = (bool)(arg1)->parseFirst((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,*arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_parseFirst) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_3:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AbstractDOMParser_parseFirst__SWIG_2); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AbstractDOMParser_parseFirst__SWIG_0); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AbstractDOMParser_parseFirst__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'AbstractDOMParser_parseFirst'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_AbstractDOMParser_parseNext) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLPScanToken *arg2 = 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_parseNext(self,token);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parseNext" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_parseNext" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseNext" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp2);
+ {
+ try
+ {
+ result = (bool)(arg1)->parseNext(*arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_parseReset) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLPScanToken *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AbstractDOMParser_parseReset(self,token);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parseReset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_parseReset" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseReset" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp2);
+ {
+ try
+ {
+ (arg1)->parseReset(*arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_handleElementPSVI) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ PSVIElement *arg4 = (PSVIElement *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: AbstractDOMParser_handleElementPSVI(self,localName,uri,elementInfo);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_handleElementPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_handleElementPSVI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"AbstractDOMParser_handleElementPSVI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIElement, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AbstractDOMParser_handleElementPSVI" "', argument " "4"" of type '" "PSVIElement *""'");
+ }
+ arg4 = reinterpret_cast< PSVIElement * >(argp4);
+ {
+ try
+ {
+ (arg1)->handleElementPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_handlePartialElementPSVI) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ PSVIElement *arg4 = (PSVIElement *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: AbstractDOMParser_handlePartialElementPSVI(self,localName,uri,elementInfo);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_handlePartialElementPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_handlePartialElementPSVI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"AbstractDOMParser_handlePartialElementPSVI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIElement, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AbstractDOMParser_handlePartialElementPSVI" "', argument " "4"" of type '" "PSVIElement *""'");
+ }
+ arg4 = reinterpret_cast< PSVIElement * >(argp4);
+ {
+ try
+ {
+ (arg1)->handlePartialElementPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_AbstractDOMParser_handleAttributesPSVI) {
+ {
+ XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ PSVIAttributeList *arg4 = (PSVIAttributeList *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: AbstractDOMParser_handleAttributesPSVI(self,localName,uri,psviAttributes);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_handleAttributesPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_handleAttributesPSVI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"AbstractDOMParser_handleAttributesPSVI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIAttributeList, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AbstractDOMParser_handleAttributesPSVI" "', argument " "4"" of type '" "PSVIAttributeList *""'");
+ }
+ arg4 = reinterpret_cast< PSVIAttributeList * >(argp4);
+ {
+ try
+ {
+ (arg1)->handleAttributesPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_XercesDOMParser__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::XMLValidator *arg1 = (XERCES_CPP_NAMESPACE::XMLValidator *) (XERCES_CPP_NAMESPACE::XMLValidator *)0 ;
+ XERCES_CPP_NAMESPACE::MemoryManager *arg2 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
+ XERCES_CPP_NAMESPACE::XMLGrammarPool *arg3 = (XERCES_CPP_NAMESPACE::XMLGrammarPool *) (XERCES_CPP_NAMESPACE::XMLGrammarPool *)0 ;
+ XERCES_CPP_NAMESPACE::XercesDOMParser *result = 0 ;
+ SV *temp1 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ arg2 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
+ if ((items < 1) || (items > 3)) {
+ SWIG_croak("Usage: new_XercesDOMParser(valToAdopt,manager,gramPool);");
+ }
+ {
+ temp1 = ST(0);
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator,0) < 0) {
+ SWIG_Perl_TypeError("_p_XERCES_CPP_NAMESPACE__XMLValidator",1,"new_XercesDOMParser");
+ }
+ }
+ if (items > 1) {
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XercesDOMParser" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp2);
+ }
+ if (items > 2) {
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XercesDOMParser" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLGrammarPool *const""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLGrammarPool * >(argp3);
+ }
+ {
+ SWIG_Disown(temp1);
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XercesDOMParser *)new XERCES_CPP_NAMESPACE::XercesDOMParser(arg1,arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_XercesDOMParser__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::XMLValidator *arg1 = (XERCES_CPP_NAMESPACE::XMLValidator *) (XERCES_CPP_NAMESPACE::XMLValidator *)0 ;
+ XERCES_CPP_NAMESPACE::XercesDOMParser *result = 0 ;
+ SV *temp1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_XercesDOMParser(valToAdopt);");
+ }
+ {
+ temp1 = ST(0);
+ if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator,0) < 0) {
+ SWIG_Perl_TypeError("_p_XERCES_CPP_NAMESPACE__XMLValidator",1,"new_XercesDOMParser");
+ }
+ }
+ {
+ SWIG_Disown(temp1);
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XercesDOMParser *)new XERCES_CPP_NAMESPACE::XercesDOMParser(arg1);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_XercesDOMParser__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_XercesDOMParser();");
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XercesDOMParser *)new XERCES_CPP_NAMESPACE::XercesDOMParser();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_XercesDOMParser) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 0) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ if (items == 1) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ if ((items >= 1) && (items <= 3)) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (items > 1) {
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (items > 2) {
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ }
+ }
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_3:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XercesDOMParser__SWIG_2); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XercesDOMParser__SWIG_1); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XercesDOMParser__SWIG_0); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_XercesDOMParser'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_XercesDOMParser) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_XercesDOMParser(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XercesDOMParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_getErrorHandler) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::ErrorHandler *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XercesDOMParser_getErrorHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::ErrorHandler *)(arg1)->getErrorHandler();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_getEntityResolver) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::EntityResolver *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XercesDOMParser_getEntityResolver(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::EntityResolver *)(arg1)->getEntityResolver();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__EntityResolver, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_getXMLEntityResolver) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLEntityResolver *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XercesDOMParser_getXMLEntityResolver(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getXMLEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLEntityResolver *)(arg1)->getXMLEntityResolver();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityResolver, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_isCachingGrammarFromParse) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XercesDOMParser_isCachingGrammarFromParse(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_isCachingGrammarFromParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::XercesDOMParser const *)arg1)->isCachingGrammarFromParse();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_isUsingCachedGrammarInParse) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XercesDOMParser_isUsingCachedGrammarInParse(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_isUsingCachedGrammarInParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::XercesDOMParser const *)arg1)->isUsingCachedGrammarInParse();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_getGrammar) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XercesDOMParser_getGrammar(self,nameSpaceKey);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"XercesDOMParser_getGrammar");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getGrammar((XMLCh const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_getRootGrammar) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XercesDOMParser_getRootGrammar(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getRootGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getRootGrammar();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_getURIText) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ unsigned int arg2 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XercesDOMParser_getURIText(self,uriId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getURIText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XercesDOMParser_getURIText" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::XercesDOMParser const *)arg1)->getURIText(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_getSrcOffset) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ unsigned int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XercesDOMParser_getSrcOffset(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getSrcOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (unsigned int)((XERCES_CPP_NAMESPACE::XercesDOMParser const *)arg1)->getSrcOffset();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_getIgnoreCachedDTD) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XercesDOMParser_getIgnoreCachedDTD(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getIgnoreCachedDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::XercesDOMParser const *)arg1)->getIgnoreCachedDTD();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_setErrorHandler) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::ErrorHandler *arg2 = (XERCES_CPP_NAMESPACE::ErrorHandler *) (XERCES_CPP_NAMESPACE::ErrorHandler *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XercesDOMParser_setErrorHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_setErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XercesDOMParser_setErrorHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setErrorHandler(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_setEntityResolver) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::EntityResolver *arg2 = (XERCES_CPP_NAMESPACE::EntityResolver *) (XERCES_CPP_NAMESPACE::EntityResolver *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XercesDOMParser_setEntityResolver(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_setEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__EntityResolver, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XercesDOMParser_setEntityResolver" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::EntityResolver *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::EntityResolver * >(argp2);
+ {
+ try
+ {
+ (arg1)->setEntityResolver(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_setXMLEntityResolver) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLEntityResolver *arg2 = (XERCES_CPP_NAMESPACE::XMLEntityResolver *) (XERCES_CPP_NAMESPACE::XMLEntityResolver *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XercesDOMParser_setXMLEntityResolver(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_setXMLEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityResolver, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XercesDOMParser_setXMLEntityResolver" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLEntityResolver *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLEntityResolver * >(argp2);
+ {
+ try
+ {
+ (arg1)->setXMLEntityResolver(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_cacheGrammarFromParse) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XercesDOMParser_cacheGrammarFromParse(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_cacheGrammarFromParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XercesDOMParser_cacheGrammarFromParse" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->cacheGrammarFromParse(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_useCachedGrammarInParse) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XercesDOMParser_useCachedGrammarInParse(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_useCachedGrammarInParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XercesDOMParser_useCachedGrammarInParse" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->useCachedGrammarInParse(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_setIgnoreCachedDTD) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XercesDOMParser_setIgnoreCachedDTD(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_setIgnoreCachedDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XercesDOMParser_setIgnoreCachedDTD" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setIgnoreCachedDTD(arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_resetDocumentPool) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XercesDOMParser_resetDocumentPool(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_resetDocumentPool" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ (arg1)->resetDocumentPool();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_error) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ unsigned int arg2 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLErrorReporter::ErrTypes arg4 ;
+ XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg6 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg7 = (XMLCh *) (XMLCh *)0 ;
+ XMLSSize_t arg8 ;
+ XMLSSize_t arg9 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
+ void *argp4 ;
+ int res4 = 0 ;
+ size_t val8 ;
+ int ecode8 = 0 ;
+ size_t val9 ;
+ int ecode9 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 9) || (items > 9)) {
+ SWIG_croak("Usage: XercesDOMParser_error(self,errCode,msgDomain,errType,errorText,systemId,publicId,lineNum,colNum);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_error" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XercesDOMParser_error" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"XercesDOMParser_error");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ {
+ res4 = SWIG_ConvertPtr(ST(3), &argp4, SWIGTYPE_p_XMLErrorReporter__ErrTypes, 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XercesDOMParser_error" "', argument " "4"" of type '" "XMLErrorReporter::ErrTypes const""'");
+ }
+ if (!argp4) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XercesDOMParser_error" "', argument " "4"" of type '" "XMLErrorReporter::ErrTypes const""'");
+ } else {
+ arg4 = *(reinterpret_cast< XMLErrorReporter::ErrTypes * >(argp4));
+ }
+ }
+
+ if (ST(4) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",5,"XercesDOMParser_error");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
+ }
+
+
+ if (ST(5) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",6,"XercesDOMParser_error");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg6 = UTF8_TRANSCODER->Perl2XMLString(ST(5));
+ }
+
+
+ if (ST(6) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",7,"XercesDOMParser_error");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg7 = UTF8_TRANSCODER->Perl2XMLString(ST(6));
+ }
+
+ ecode8 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(7), &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "XercesDOMParser_error" "', argument " "8"" of type '" "XMLSSize_t""'");
+ }
+ arg8 = static_cast< XMLSSize_t >(val8);
+ ecode9 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(8), &val9);
+ if (!SWIG_IsOK(ecode9)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "XercesDOMParser_error" "', argument " "9"" of type '" "XMLSSize_t""'");
+ }
+ arg9 = static_cast< XMLSSize_t >(val9);
+ {
+ try
+ {
+ (arg1)->error(arg2,(XMLCh const *)arg3,arg4,(XMLCh const *)arg5,(XMLCh const *)arg6,(XMLCh const *)arg7,arg8,arg9);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+
+
+ delete[] arg3;
+
+
+ delete[] arg5;
+
+
+ delete[] arg6;
+
+
+ delete[] arg7;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ delete[] arg3;
+
+
+ delete[] arg5;
+
+
+ delete[] arg6;
+
+
+ delete[] arg7;
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_resetErrors) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XercesDOMParser_resetErrors(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_resetErrors" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ (arg1)->resetErrors();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_loadGrammar__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::InputSource *arg2 = 0 ;
+ short arg3 ;
+ bool arg4 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ short val3 ;
+ int ecode3 = 0 ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: XercesDOMParser_loadGrammar(self,source,grammarType,toCache);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XercesDOMParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XercesDOMParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
+ ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XercesDOMParser_loadGrammar" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = static_cast< short >(val3);
+ ecode4 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XercesDOMParser_loadGrammar" "', argument " "4"" of type '" "bool""'");
+ }
+ arg4 = static_cast< bool >(val4);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_loadGrammar__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::InputSource *arg2 = 0 ;
+ short arg3 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ short val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: XercesDOMParser_loadGrammar(self,source,grammarType);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XercesDOMParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XercesDOMParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
+ ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XercesDOMParser_loadGrammar" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = static_cast< short >(val3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_loadGrammar__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ short arg3 ;
+ bool arg4 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ short val3 ;
+ int ecode3 = 0 ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: XercesDOMParser_loadGrammar(self,systemId,grammarType,toCache);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"XercesDOMParser_loadGrammar");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XercesDOMParser_loadGrammar" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = static_cast< short >(val3);
+ ecode4 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XercesDOMParser_loadGrammar" "', argument " "4"" of type '" "bool""'");
+ }
+ arg4 = static_cast< bool >(val4);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3,arg4);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_loadGrammar__SWIG_3) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ short arg3 ;
+ XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ short val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: XercesDOMParser_loadGrammar(self,systemId,grammarType);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"XercesDOMParser_loadGrammar");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XercesDOMParser_loadGrammar" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = static_cast< short >(val3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XercesDOMParser_loadGrammar) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ if (items == 4) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_3:
+
+ if (items == 4) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 4;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_4:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XercesDOMParser_loadGrammar__SWIG_1); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XercesDOMParser_loadGrammar__SWIG_3); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XercesDOMParser_loadGrammar__SWIG_0); return;
+ case 4:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XercesDOMParser_loadGrammar__SWIG_2); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'XercesDOMParser_loadGrammar'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_XercesDOMParser_resetCachedGrammarPool) {
+ {
+ XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XercesDOMParser_resetCachedGrammarPool(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_resetCachedGrammarPool" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ {
+ try
+ {
+ (arg1)->resetCachedGrammarPool();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_PerlNodeFilterCallbackHandler__SWIG_0) {
+ {
+ PerlNodeFilterCallbackHandler *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_PerlNodeFilterCallbackHandler();");
+ }
+ {
+ try
+ {
+ result = (PerlNodeFilterCallbackHandler *)new PerlNodeFilterCallbackHandler();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlNodeFilterCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_PerlNodeFilterCallbackHandler__SWIG_1) {
+ {
+ SV *arg1 = (SV *) 0 ;
+ PerlNodeFilterCallbackHandler *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_PerlNodeFilterCallbackHandler(obj);");
+ }
+ {
+ arg1 = ST(0);
+ }
+ {
+ try
+ {
+ result = (PerlNodeFilterCallbackHandler *)new PerlNodeFilterCallbackHandler(arg1);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlNodeFilterCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_PerlNodeFilterCallbackHandler) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 0) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ if (items == 1) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ _v = SvOK(ST(0)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_PerlNodeFilterCallbackHandler__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_PerlNodeFilterCallbackHandler__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_PerlNodeFilterCallbackHandler'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_PerlNodeFilterCallbackHandler) {
+ {
+ PerlNodeFilterCallbackHandler *arg1 = (PerlNodeFilterCallbackHandler *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_PerlNodeFilterCallbackHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_PerlNodeFilterCallbackHandler, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PerlNodeFilterCallbackHandler" "', argument " "1"" of type '" "PerlNodeFilterCallbackHandler *""'");
+ }
+ arg1 = reinterpret_cast< PerlNodeFilterCallbackHandler * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_DOM_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PerlNodeFilterCallbackHandler_type) {
+ {
+ PerlNodeFilterCallbackHandler *arg1 = (PerlNodeFilterCallbackHandler *) 0 ;
+ int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: PerlNodeFilterCallbackHandler_type(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_PerlNodeFilterCallbackHandler, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlNodeFilterCallbackHandler_type" "', argument " "1"" of type '" "PerlNodeFilterCallbackHandler *""'");
+ }
+ arg1 = reinterpret_cast< PerlNodeFilterCallbackHandler * >(argp1);
+ {
+ try
+ {
+ result = (int)(arg1)->type();
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PerlNodeFilterCallbackHandler_acceptNode) {
+ {
+ PerlNodeFilterCallbackHandler *arg1 = (PerlNodeFilterCallbackHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ short result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: PerlNodeFilterCallbackHandler_acceptNode(self,node);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_PerlNodeFilterCallbackHandler, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlNodeFilterCallbackHandler_acceptNode" "', argument " "1"" of type '" "PerlNodeFilterCallbackHandler const *""'");
+ }
+ arg1 = reinterpret_cast< PerlNodeFilterCallbackHandler * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PerlNodeFilterCallbackHandler_acceptNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ {
+ try
+ {
+ result = (short)((PerlNodeFilterCallbackHandler const *)arg1)->acceptNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ }
+ CATCH_DOM_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMXPathEvaluator *) ((XERCES_CPP_NAMESPACE::DOMDocument *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilterTo_p_XERCES_CPP_NAMESPACE__DOMNodeFilter(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNodeFilter *) ((XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *) x));
+}
+static void *_p_PerlNodeFilterCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__DOMNodeFilter(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNodeFilter *) ((PerlNodeFilterCallbackHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMAttrTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMAttr *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMNotationTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMNotation *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) (XERCES_CPP_NAMESPACE::DOMCharacterData *) ((XERCES_CPP_NAMESPACE::DOMText *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentFragmentTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMDocumentFragment *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMXPathNamespaceTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMXPathNamespace *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) (XERCES_CPP_NAMESPACE::DOMCharacterData *)(XERCES_CPP_NAMESPACE::DOMText *) ((XERCES_CPP_NAMESPACE::DOMCDATASection *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMEntityReferenceTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMEntityReference *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMEntityTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMEntity *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMCharacterDataTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMCharacterData *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentTypeTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMDocumentType *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) (XERCES_CPP_NAMESPACE::DOMCharacterData *) ((XERCES_CPP_NAMESPACE::DOMComment *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMDocument *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMElementTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMElement *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMProcessingInstructionTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMRangeExceptionTo_p_XERCES_CPP_NAMESPACE__DOMException(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMException *) ((XERCES_CPP_NAMESPACE::DOMRangeException *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMLSExceptionTo_p_XERCES_CPP_NAMESPACE__DOMException(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMException *) ((XERCES_CPP_NAMESPACE::DOMLSException *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMDocumentTraversal *) ((XERCES_CPP_NAMESPACE::DOMDocument *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__AbstractDOMParser(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::AbstractDOMParser *) ((XERCES_CPP_NAMESPACE::XercesDOMParser *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__Wrapper4InputSourceTo_p_XERCES_CPP_NAMESPACE__DOMLSInput(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMLSInput *) ((XERCES_CPP_NAMESPACE::Wrapper4InputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__EntityResolver(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::EntityResolver *) ((XERCES_CPP_NAMESPACE::HandlerBase *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__EntityResolver(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::EntityResolver *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
+}
+static void *_p_PerlEntityResolverHandlerTo_p_XERCES_CPP_NAMESPACE__EntityResolver(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::EntityResolver *) ((PerlEntityResolverHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__AbstractDOMParserTo_p_XERCES_CPP_NAMESPACE__PSVIHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::PSVIHandler *) ((XERCES_CPP_NAMESPACE::AbstractDOMParser *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__PSVIHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::PSVIHandler *) (XERCES_CPP_NAMESPACE::AbstractDOMParser *) ((XERCES_CPP_NAMESPACE::XercesDOMParser *) x));
+}
+static void *_p_PerlErrorCallbackHandlerTo_p_PerlCallbackHandler(void *x) {
+ return (void *)((PerlCallbackHandler *) ((PerlErrorCallbackHandler *) x));
+}
+static void *_p_PerlEntityResolverHandlerTo_p_PerlCallbackHandler(void *x) {
+ return (void *)((PerlCallbackHandler *) ((PerlEntityResolverHandler *) x));
+}
+static void *_p_PerlDocumentCallbackHandlerTo_p_PerlCallbackHandler(void *x) {
+ return (void *)((PerlCallbackHandler *) ((PerlDocumentCallbackHandler *) x));
+}
+static void *_p_PerlContentCallbackHandlerTo_p_PerlCallbackHandler(void *x) {
+ return (void *)((PerlCallbackHandler *) ((PerlContentCallbackHandler *) x));
+}
+static void *_p_PerlNodeFilterCallbackHandlerTo_p_PerlCallbackHandler(void *x) {
+ return (void *)((PerlCallbackHandler *) ((PerlNodeFilterCallbackHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__ErrorHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::ErrorHandler *) ((XERCES_CPP_NAMESPACE::HandlerBase *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__ErrorHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::ErrorHandler *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
+}
+static void *_p_PerlErrorCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__ErrorHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::ErrorHandler *) ((PerlErrorCallbackHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMText(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMText *) ((XERCES_CPP_NAMESPACE::DOMCDATASection *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMImplementationTo_p_XERCES_CPP_NAMESPACE__DOMImplementationLS(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMImplementationLS *) ((XERCES_CPP_NAMESPACE::DOMImplementation *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMCharacterData *) ((XERCES_CPP_NAMESPACE::DOMText *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMCharacterData *) ((XERCES_CPP_NAMESPACE::DOMComment *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMCharacterData *) (XERCES_CPP_NAMESPACE::DOMText *) ((XERCES_CPP_NAMESPACE::DOMCDATASection *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__LocalFileInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::LocalFileInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__StdInInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::StdInInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__URLInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::URLInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__MemBufInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::MemBufInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInputTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DTDGrammarTo_p_XERCES_CPP_NAMESPACE__Grammar(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::Grammar *) ((XERCES_CPP_NAMESPACE::DTDGrammar *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SchemaGrammarTo_p_XERCES_CPP_NAMESPACE__Grammar(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::Grammar *) ((XERCES_CPP_NAMESPACE::SchemaGrammar *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMDocumentRange(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DOMDocumentRange *) ((XERCES_CPP_NAMESPACE::DOMDocument *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__StdOutFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::StdOutFormatTarget *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__LocalFileFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::LocalFileFormatTarget *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__MemBufFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::MemBufFormatTarget *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLSchemaDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLGrammarDescription *) ((XERCES_CPP_NAMESPACE::XMLSchemaDescription *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLGrammarDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLGrammarDescription *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLDTDDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLGrammarDescription *) ((XERCES_CPP_NAMESPACE::XMLDTDDescription *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SchemaElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLElementDecl *) ((XERCES_CPP_NAMESPACE::SchemaElementDecl *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DTDElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLElementDecl *) ((XERCES_CPP_NAMESPACE::DTDElementDecl *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLElementDecl *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SchemaValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLValidator *) ((XERCES_CPP_NAMESPACE::SchemaValidator *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DTDValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLValidator *) ((XERCES_CPP_NAMESPACE::DTDValidator *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLValidator *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLPScanTokenTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLPScanToken *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::RefHash3KeysIdPoolEnumerator<XERCES_CPP_NAMESPACE::SchemaElementDecl > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DTDAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLAttDef *) ((XERCES_CPP_NAMESPACE::DTDAttDef *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLAttDef *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::SAXParser *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLNotationDeclTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLNotationDecl *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLFormatTarget *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__StdOutFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::StdOutFormatTarget *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__LocalFileFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::LocalFileFormatTarget *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__MemBufFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::MemBufFormatTarget *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLURLTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLURL *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__LocalFileInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::LocalFileInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__InputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::InputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__StdInInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::StdInInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__URLInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::URLInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__MemBufInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::MemBufInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SchemaAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLAttDef *) ((XERCES_CPP_NAMESPACE::SchemaAttDef *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__AbstractDOMParserTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::AbstractDOMParser *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::AbstractDOMParser *) ((XERCES_CPP_NAMESPACE::XercesDOMParser *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLException *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLContentModelTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLContentModel *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__QNameTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::QName *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SchemaGrammarTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::Grammar *) ((XERCES_CPP_NAMESPACE::SchemaGrammar *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DTDGrammarTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::Grammar *) ((XERCES_CPP_NAMESPACE::DTDGrammar *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__GrammarTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::Grammar *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SAXExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::SAXException *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SAXNotSupportedExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::SAXException *) ((XERCES_CPP_NAMESPACE::SAXNotSupportedException *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::SAXException *) ((XERCES_CPP_NAMESPACE::SAXNotRecognizedException *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SAXParseExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::SAXException *) ((XERCES_CPP_NAMESPACE::SAXParseException *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::NameIdPoolEnumerator<XERCES_CPP_NAMESPACE::DTDEntityDecl > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::NameIdPoolEnumerator<XERCES_CPP_NAMESPACE::DTDElementDecl > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::NameIdPool<XERCES_CPP_NAMESPACE::DTDEntityDecl > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::NameIdPool<XERCES_CPP_NAMESPACE::DTDElementDecl > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::RefHash3KeysIdPool<XERCES_CPP_NAMESPACE::SchemaElementDecl > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SchemaAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLAttDefList *) ((XERCES_CPP_NAMESPACE::SchemaAttDefList *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DTDAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLAttDefList *) ((XERCES_CPP_NAMESPACE::DTDAttDefList *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLAttDefList *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLUriTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLUri *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInputTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLFormatterTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLFormatter *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DTDEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLEntityDecl *) ((XERCES_CPP_NAMESPACE::DTDEntityDecl *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLEntityDecl *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DTDValidatorTo_p_XERCES_CPP_NAMESPACE__XMLValidator(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLValidator *) ((XERCES_CPP_NAMESPACE::DTDValidator *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SchemaValidatorTo_p_XERCES_CPP_NAMESPACE__XMLValidator(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLValidator *) ((XERCES_CPP_NAMESPACE::SchemaValidator *) x));
+}
+static swig_type_info _swigt__p_PSVIAttributeList = {"_p_PSVIAttributeList", "PSVIAttributeList *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_PSVIElement = {"_p_PSVIElement", "PSVIElement *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_PerlCallbackHandler = {"_p_PerlCallbackHandler", "PerlCallbackHandler *", 0, 0, (void*)"XML::Xerces::PerlCallbackHandler", 0};
+static swig_type_info _swigt__p_PerlErrorCallbackHandler = {"_p_PerlErrorCallbackHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_PerlEntityResolverHandler = {"_p_PerlEntityResolverHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_PerlDocumentCallbackHandler = {"_p_PerlDocumentCallbackHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_PerlContentCallbackHandler = {"_p_PerlContentCallbackHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_PerlNodeFilterCallbackHandler = {"_p_PerlNodeFilterCallbackHandler", "PerlNodeFilterCallbackHandler *", 0, 0, (void*)"XML::Xerces::PerlNodeFilterCallbackHandler", 0};
+static swig_type_info _swigt__p_SecurityManager = {"_p_SecurityManager", "SecurityManager *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t = {"_p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t", "ValueVectorOf<XERCES_CPP_NAMESPACE::SchemaElementDecl * > *|XERCES_CPP_NAMESPACE::ElemVector *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__AbstractDOMParser = {"_p_XERCES_CPP_NAMESPACE__AbstractDOMParser", "XERCES_CPP_NAMESPACE::AbstractDOMParser *", 0, 0, (void*)"XML::Xerces::AbstractDOMParser", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__BinInputStream = {"_p_XERCES_CPP_NAMESPACE__BinInputStream", "XERCES_CPP_NAMESPACE::BinInputStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMAttr = {"_p_XERCES_CPP_NAMESPACE__DOMAttr", "XERCES_CPP_NAMESPACE::DOMAttr *", 0, 0, (void*)"XML::Xerces::DOMAttr", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection = {"_p_XERCES_CPP_NAMESPACE__DOMCDATASection", "XERCES_CPP_NAMESPACE::DOMCDATASection *", 0, 0, (void*)"XML::Xerces::DOMCDATASection", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData = {"_p_XERCES_CPP_NAMESPACE__DOMCharacterData", "XERCES_CPP_NAMESPACE::DOMCharacterData *", 0, 0, (void*)"XML::Xerces::DOMCharacterData", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMComment = {"_p_XERCES_CPP_NAMESPACE__DOMComment", "XERCES_CPP_NAMESPACE::DOMComment *", 0, 0, (void*)"XML::Xerces::DOMComment", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMConfiguration = {"_p_XERCES_CPP_NAMESPACE__DOMConfiguration", "XERCES_CPP_NAMESPACE::DOMConfiguration *", 0, 0, (void*)"XML::Xerces::DOMConfiguration", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocument = {"_p_XERCES_CPP_NAMESPACE__DOMDocument", "XERCES_CPP_NAMESPACE::DOMDocument *", 0, 0, (void*)"XML::Xerces::DOMDocument", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment = {"_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment", "XERCES_CPP_NAMESPACE::DOMDocumentFragment *", 0, 0, (void*)"XML::Xerces::DOMDocumentFragment", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentRange = {"_p_XERCES_CPP_NAMESPACE__DOMDocumentRange", "XERCES_CPP_NAMESPACE::DOMDocumentRange *", 0, 0, (void*)"XML::Xerces::DOMDocumentRange", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal = {"_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal", "XERCES_CPP_NAMESPACE::DOMDocumentTraversal *", 0, 0, (void*)"XML::Xerces::DOMDocumentTraversal", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType = {"_p_XERCES_CPP_NAMESPACE__DOMDocumentType", "XERCES_CPP_NAMESPACE::DOMDocumentType *", 0, 0, (void*)"XML::Xerces::DOMDocumentType", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMElement = {"_p_XERCES_CPP_NAMESPACE__DOMElement", "XERCES_CPP_NAMESPACE::DOMElement *", 0, 0, (void*)"XML::Xerces::DOMElement", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMEntity = {"_p_XERCES_CPP_NAMESPACE__DOMEntity", "XERCES_CPP_NAMESPACE::DOMEntity *", 0, 0, (void*)"XML::Xerces::DOMEntity", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference = {"_p_XERCES_CPP_NAMESPACE__DOMEntityReference", "XERCES_CPP_NAMESPACE::DOMEntityReference *", 0, 0, (void*)"XML::Xerces::DOMEntityReference", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMError = {"_p_XERCES_CPP_NAMESPACE__DOMError", "XERCES_CPP_NAMESPACE::DOMError *", 0, 0, (void*)"XML::Xerces::DOMError", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMErrorHandler = {"_p_XERCES_CPP_NAMESPACE__DOMErrorHandler", "XERCES_CPP_NAMESPACE::DOMErrorHandler *", 0, 0, (void*)"XML::Xerces::DOMErrorHandler", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMException = {"_p_XERCES_CPP_NAMESPACE__DOMException", "XERCES_CPP_NAMESPACE::DOMException *", 0, 0, (void*)"XML::Xerces::DOMException", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMImplementation = {"_p_XERCES_CPP_NAMESPACE__DOMImplementation", "XERCES_CPP_NAMESPACE::DOMImplementation *", 0, 0, (void*)"XML::Xerces::DOMImplementation", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationLS = {"_p_XERCES_CPP_NAMESPACE__DOMImplementationLS", "XERCES_CPP_NAMESPACE::DOMImplementationLS *", 0, 0, (void*)"XML::Xerces::DOMImplementationLS", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationList = {"_p_XERCES_CPP_NAMESPACE__DOMImplementationList", "XERCES_CPP_NAMESPACE::DOMImplementationList *", 0, 0, (void*)"XML::Xerces::DOMImplementationList", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry = {"_p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry", "XERCES_CPP_NAMESPACE::DOMImplementationRegistry *", 0, 0, (void*)"XML::Xerces::DOMImplementationRegistry", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationSource = {"_p_XERCES_CPP_NAMESPACE__DOMImplementationSource", "XERCES_CPP_NAMESPACE::DOMImplementationSource *", 0, 0, (void*)"XML::Xerces::DOMImplementationSource", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSException = {"_p_XERCES_CPP_NAMESPACE__DOMLSException", "XERCES_CPP_NAMESPACE::DOMLSException *", 0, 0, (void*)"XML::Xerces::DOMLSException", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSInput = {"_p_XERCES_CPP_NAMESPACE__DOMLSInput", "XERCES_CPP_NAMESPACE::DOMLSInput *", 0, 0, (void*)"XML::Xerces::DOMLSInput", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSOutput = {"_p_XERCES_CPP_NAMESPACE__DOMLSOutput", "XERCES_CPP_NAMESPACE::DOMLSOutput *", 0, 0, (void*)"XML::Xerces::DOMLSOutput", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSParser = {"_p_XERCES_CPP_NAMESPACE__DOMLSParser", "XERCES_CPP_NAMESPACE::DOMLSParser *", 0, 0, (void*)"XML::Xerces::DOMLSParser", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSParserFilter = {"_p_XERCES_CPP_NAMESPACE__DOMLSParserFilter", "XERCES_CPP_NAMESPACE::DOMLSParserFilter *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver = {"_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver", "XERCES_CPP_NAMESPACE::DOMLSResourceResolver *", 0, 0, (void*)"XML::Xerces::DOMLSResourceResolver", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializer = {"_p_XERCES_CPP_NAMESPACE__DOMLSSerializer", "XERCES_CPP_NAMESPACE::DOMLSSerializer *", 0, 0, (void*)"XML::Xerces::DOMLSSerializer", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter = {"_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter", "XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *", 0, 0, (void*)"XML::Xerces::DOMLSSerializerFilter", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLocator = {"_p_XERCES_CPP_NAMESPACE__DOMLocator", "XERCES_CPP_NAMESPACE::DOMLocator *", 0, 0, (void*)"XML::Xerces::DOMLocator", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap = {"_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap", "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *", 0, 0, (void*)"XML::Xerces::DOMNamedNodeMap", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNode = {"_p_XERCES_CPP_NAMESPACE__DOMNode", "XERCES_CPP_NAMESPACE::DOMNode *", 0, 0, (void*)"XML::Xerces::DOMNode", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNodeFilter = {"_p_XERCES_CPP_NAMESPACE__DOMNodeFilter", "XERCES_CPP_NAMESPACE::DOMNodeFilter *", 0, 0, (void*)"XML::Xerces::DOMNodeFilter", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNodeIterator = {"_p_XERCES_CPP_NAMESPACE__DOMNodeIterator", "XERCES_CPP_NAMESPACE::DOMNodeIterator *", 0, 0, (void*)"XML::Xerces::DOMNodeIterator", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNodeList = {"_p_XERCES_CPP_NAMESPACE__DOMNodeList", "XERCES_CPP_NAMESPACE::DOMNodeList *", 0, 0, (void*)"XML::Xerces::DOMNodeList", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNotation = {"_p_XERCES_CPP_NAMESPACE__DOMNotation", "XERCES_CPP_NAMESPACE::DOMNotation *", 0, 0, (void*)"XML::Xerces::DOMNotation", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo = {"_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo", "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *", 0, 0, (void*)"XML::Xerces::DOMPSVITypeInfo", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction = {"_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction", "XERCES_CPP_NAMESPACE::DOMProcessingInstruction *", 0, 0, (void*)"XML::Xerces::DOMProcessingInstruction", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMRange = {"_p_XERCES_CPP_NAMESPACE__DOMRange", "XERCES_CPP_NAMESPACE::DOMRange *", 0, 0, (void*)"XML::Xerces::DOMRange", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMRangeException = {"_p_XERCES_CPP_NAMESPACE__DOMRangeException", "XERCES_CPP_NAMESPACE::DOMRangeException *", 0, 0, (void*)"XML::Xerces::DOMRangeException", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMStringList = {"_p_XERCES_CPP_NAMESPACE__DOMStringList", "XERCES_CPP_NAMESPACE::DOMStringList *", 0, 0, (void*)"XML::Xerces::DOMStringList", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMText = {"_p_XERCES_CPP_NAMESPACE__DOMText", "XERCES_CPP_NAMESPACE::DOMText *", 0, 0, (void*)"XML::Xerces::DOMText", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMTreeWalker = {"_p_XERCES_CPP_NAMESPACE__DOMTreeWalker", "XERCES_CPP_NAMESPACE::DOMTreeWalker *", 0, 0, (void*)"XML::Xerces::DOMTreeWalker", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMTypeInfo = {"_p_XERCES_CPP_NAMESPACE__DOMTypeInfo", "XERCES_CPP_NAMESPACE::DOMTypeInfo *", 0, 0, (void*)"XML::Xerces::DOMTypeInfo", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler = {"_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler", "XERCES_CPP_NAMESPACE::DOMUserDataHandler *", 0, 0, (void*)"XML::Xerces::DOMUserDataHandler", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator = {"_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator", "XERCES_CPP_NAMESPACE::DOMXPathEvaluator *", 0, 0, (void*)"XML::Xerces::DOMXPathEvaluator", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathException = {"_p_XERCES_CPP_NAMESPACE__DOMXPathException", "XERCES_CPP_NAMESPACE::DOMXPathException *", 0, 0, (void*)"XML::Xerces::DOMXPathException", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathExpression = {"_p_XERCES_CPP_NAMESPACE__DOMXPathExpression", "XERCES_CPP_NAMESPACE::DOMXPathExpression *", 0, 0, (void*)"XML::Xerces::DOMXPathExpression", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver = {"_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver", "XERCES_CPP_NAMESPACE::DOMXPathNSResolver *", 0, 0, (void*)"XML::Xerces::DOMXPathNSResolver", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace = {"_p_XERCES_CPP_NAMESPACE__DOMXPathNamespace", "XERCES_CPP_NAMESPACE::DOMXPathNamespace *", 0, 0, (void*)"XML::Xerces::DOMXPathNamespace", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathResult = {"_p_XERCES_CPP_NAMESPACE__DOMXPathResult", "XERCES_CPP_NAMESPACE::DOMXPathResult *", 0, 0, (void*)"XML::Xerces::DOMXPathResult", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__EntityResolver = {"_p_XERCES_CPP_NAMESPACE__EntityResolver", "XERCES_CPP_NAMESPACE::EntityResolver *", 0, 0, (void*)"XML::Xerces::EntityResolver", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__HandlerBase = {"_p_XERCES_CPP_NAMESPACE__HandlerBase", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DefaultHandler = {"_p_XERCES_CPP_NAMESPACE__DefaultHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__ErrorHandler = {"_p_XERCES_CPP_NAMESPACE__ErrorHandler", "XERCES_CPP_NAMESPACE::ErrorHandler *", 0, 0, (void*)"XML::Xerces::ErrorHandler", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__Grammar = {"_p_XERCES_CPP_NAMESPACE__Grammar", "XERCES_CPP_NAMESPACE::Grammar *", 0, 0, (void*)"XML::Xerces::Grammar", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DTDGrammar = {"_p_XERCES_CPP_NAMESPACE__DTDGrammar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SchemaGrammar = {"_p_XERCES_CPP_NAMESPACE__SchemaGrammar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__InputSource = {"_p_XERCES_CPP_NAMESPACE__InputSource", "XERCES_CPP_NAMESPACE::InputSource *", 0, 0, (void*)"XML::Xerces::InputSource", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource = {"_p_XERCES_CPP_NAMESPACE__LocalFileInputSource", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource = {"_p_XERCES_CPP_NAMESPACE__StdInInputSource", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__URLInputSource = {"_p_XERCES_CPP_NAMESPACE__URLInputSource", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource = {"_p_XERCES_CPP_NAMESPACE__MemBufInputSource", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget = {"_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget", "XERCES_CPP_NAMESPACE::LocalFileFormatTarget *", 0, 0, (void*)"XML::Xerces::LocalFileFormatTarget", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget = {"_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget", "XERCES_CPP_NAMESPACE::MemBufFormatTarget *", 0, 0, (void*)"XML::Xerces::MemBufFormatTarget", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__MemoryManager = {"_p_XERCES_CPP_NAMESPACE__MemoryManager", "XERCES_CPP_NAMESPACE::MemoryManager *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__PSVIHandler = {"_p_XERCES_CPP_NAMESPACE__PSVIHandler", "XERCES_CPP_NAMESPACE::PSVIHandler *", 0, 0, (void*)"XML::Xerces::PSVIHandler", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget = {"_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget", "XERCES_CPP_NAMESPACE::StdOutFormatTarget *", 0, 0, (void*)"XML::Xerces::StdOutFormatTarget", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput = {"_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput", "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *", 0, 0, (void*)"XML::Xerces::Wrapper4DOMLSInput", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource = {"_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource", "XERCES_CPP_NAMESPACE::Wrapper4InputSource *", 0, 0, (void*)"XML::Xerces::Wrapper4InputSource", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLEntityResolver = {"_p_XERCES_CPP_NAMESPACE__XMLEntityResolver", "XERCES_CPP_NAMESPACE::XMLEntityResolver *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLFormatTarget = {"_p_XERCES_CPP_NAMESPACE__XMLFormatTarget", "XERCES_CPP_NAMESPACE::XMLFormatTarget *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLFormatter = {"_p_XERCES_CPP_NAMESPACE__XMLFormatter", "XERCES_CPP_NAMESPACE::XMLFormatter *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarPool = {"_p_XERCES_CPP_NAMESPACE__XMLGrammarPool", "XERCES_CPP_NAMESPACE::XMLGrammarPool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLPScanToken = {"_p_XERCES_CPP_NAMESPACE__XMLPScanToken", "XERCES_CPP_NAMESPACE::XMLPScanToken *", 0, 0, (void*)"XML::Xerces::XMLPScanToken", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLValidator = {"_p_XERCES_CPP_NAMESPACE__XMLValidator", "XERCES_CPP_NAMESPACE::XMLValidator *", 0, 0, (void*)"XML::Xerces::XMLValidator", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DTDValidator = {"_p_XERCES_CPP_NAMESPACE__DTDValidator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator = {"_p_XERCES_CPP_NAMESPACE__SchemaValidator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMemory = {"_p_XERCES_CPP_NAMESPACE__XMemory", "XERCES_CPP_NAMESPACE::XMemory *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLUri = {"_p_XERCES_CPP_NAMESPACE__XMLUri", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLSchemaDescription = {"_p_XERCES_CPP_NAMESPACE__XMLSchemaDescription", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription = {"_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLDTDDescription = {"_p_XERCES_CPP_NAMESPACE__XMLDTDDescription", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SchemaElementDecl = {"_p_XERCES_CPP_NAMESPACE__SchemaElementDecl", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DTDElementDecl = {"_p_XERCES_CPP_NAMESPACE__DTDElementDecl", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLElementDecl = {"_p_XERCES_CPP_NAMESPACE__XMLElementDecl", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t = {"_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLAttDef = {"_p_XERCES_CPP_NAMESPACE__XMLAttDef", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef = {"_p_XERCES_CPP_NAMESPACE__DTDAttDef", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SAXParser = {"_p_XERCES_CPP_NAMESPACE__SAXParser", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl = {"_p_XERCES_CPP_NAMESPACE__XMLNotationDecl", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t = {"_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t = {"_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDef = {"_p_XERCES_CPP_NAMESPACE__SchemaAttDef", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLURL = {"_p_XERCES_CPP_NAMESPACE__XMLURL", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLException = {"_p_XERCES_CPP_NAMESPACE__XMLException", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLContentModel = {"_p_XERCES_CPP_NAMESPACE__XMLContentModel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SAXException = {"_p_XERCES_CPP_NAMESPACE__SAXException", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SAXNotSupportedException = {"_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException = {"_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SAXParseException = {"_p_XERCES_CPP_NAMESPACE__SAXParseException", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t = {"_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t = {"_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t = {"_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__QName = {"_p_XERCES_CPP_NAMESPACE__QName", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDefList = {"_p_XERCES_CPP_NAMESPACE__SchemaAttDefList", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DTDAttDefList = {"_p_XERCES_CPP_NAMESPACE__DTDAttDefList", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLAttDefList = {"_p_XERCES_CPP_NAMESPACE__XMLAttDefList", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DTDEntityDecl = {"_p_XERCES_CPP_NAMESPACE__DTDEntityDecl", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLEntityDecl = {"_p_XERCES_CPP_NAMESPACE__XMLEntityDecl", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser = {"_p_XERCES_CPP_NAMESPACE__XercesDOMParser", "XERCES_CPP_NAMESPACE::XercesDOMParser *", 0, 0, (void*)"XML::Xerces::XercesDOMParser", 0};
+static swig_type_info _swigt__p_XMLErrorReporter__ErrTypes = {"_p_XMLErrorReporter__ErrTypes", "XMLErrorReporter::ErrTypes *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int32_t = {"_p_int32_t", "int32_t *|XMLInt32 *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *|XMLSize_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ssize_t = {"_p_ssize_t", "ssize_t *|XMLSSize_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_uint16_t = {"_p_uint16_t", "uint16_t *|UTF16Ch *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *|UCS4Ch *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|XMLByte *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+ &_swigt__p_PSVIAttributeList,
+ &_swigt__p_PSVIElement,
+ &_swigt__p_PerlCallbackHandler,
+ &_swigt__p_PerlContentCallbackHandler,
+ &_swigt__p_PerlDocumentCallbackHandler,
+ &_swigt__p_PerlEntityResolverHandler,
+ &_swigt__p_PerlErrorCallbackHandler,
+ &_swigt__p_PerlNodeFilterCallbackHandler,
+ &_swigt__p_SecurityManager,
+ &_swigt__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__AbstractDOMParser,
+ &_swigt__p_XERCES_CPP_NAMESPACE__BinInputStream,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMAttr,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMComment,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMConfiguration,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentRange,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMElement,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMEntity,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMError,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMErrorHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMException,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementation,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationLS,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationList,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationSource,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSException,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSInput,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSOutput,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSParser,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSParserFilter,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializer,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMLocator,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMNode,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeFilter,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeIterator,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeList,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMNotation,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMRange,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMRangeException,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMStringList,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMText,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMTreeWalker,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMTypeInfo,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathException,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathExpression,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathResult,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDefList,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DTDElementDecl,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DTDEntityDecl,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DTDGrammar,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DTDValidator,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DefaultHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__EntityResolver,
+ &_swigt__p_XERCES_CPP_NAMESPACE__ErrorHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__Grammar,
+ &_swigt__p_XERCES_CPP_NAMESPACE__HandlerBase,
+ &_swigt__p_XERCES_CPP_NAMESPACE__InputSource,
+ &_swigt__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget,
+ &_swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource,
+ &_swigt__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget,
+ &_swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource,
+ &_swigt__p_XERCES_CPP_NAMESPACE__MemoryManager,
+ &_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PSVIHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__QName,
+ &_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__SAXException,
+ &_swigt__p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException,
+ &_swigt__p_XERCES_CPP_NAMESPACE__SAXNotSupportedException,
+ &_swigt__p_XERCES_CPP_NAMESPACE__SAXParseException,
+ &_swigt__p_XERCES_CPP_NAMESPACE__SAXParser,
+ &_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDef,
+ &_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDefList,
+ &_swigt__p_XERCES_CPP_NAMESPACE__SchemaElementDecl,
+ &_swigt__p_XERCES_CPP_NAMESPACE__SchemaGrammar,
+ &_swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator,
+ &_swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource,
+ &_swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget,
+ &_swigt__p_XERCES_CPP_NAMESPACE__URLInputSource,
+ &_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput,
+ &_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDef,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDefList,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLContentModel,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLDTDDescription,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLElementDecl,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLEntityDecl,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLEntityResolver,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLException,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatTarget,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatter,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarPool,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLPScanToken,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLSchemaDescription,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLURL,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLUri,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLValidator,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMemory,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser,
+ &_swigt__p_XMLErrorReporter__ErrTypes,
+ &_swigt__p_char,
+ &_swigt__p_int32_t,
+ &_swigt__p_size_t,
+ &_swigt__p_ssize_t,
+ &_swigt__p_uint16_t,
+ &_swigt__p_uint32_t,
+ &_swigt__p_unsigned_char,
+ &_swigt__p_void,
+};
+
+static swig_cast_info _swigc__p_PSVIAttributeList[] = { {&_swigt__p_PSVIAttributeList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_PSVIElement[] = { {&_swigt__p_PSVIElement, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_PerlErrorCallbackHandler[] = {{&_swigt__p_PerlErrorCallbackHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_PerlEntityResolverHandler[] = {{&_swigt__p_PerlEntityResolverHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_PerlDocumentCallbackHandler[] = {{&_swigt__p_PerlDocumentCallbackHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_PerlContentCallbackHandler[] = {{&_swigt__p_PerlContentCallbackHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_PerlCallbackHandler[] = { {&_swigt__p_PerlCallbackHandler, 0, 0, 0}, {&_swigt__p_PerlErrorCallbackHandler, _p_PerlErrorCallbackHandlerTo_p_PerlCallbackHandler, 0, 0}, {&_swigt__p_PerlEntityResolverHandler, _p_PerlEntityResolverHandlerTo_p_PerlCallbackHandler, 0, 0}, {&_swigt__p_PerlDocumentCallbackHandler, _p_PerlDocumentCallbackHandlerTo_p_PerlCallbackHandler, 0, 0}, {&_swigt__p_PerlContentCallbackHandler, _p_PerlContentCallbackHandlerTo_p_PerlCallbackHandler, 0, 0}, {&_swigt__p_PerlNodeFilterCallbackHandler, _p_PerlNodeFilterCallbackHandlerTo_p_PerlCallbackHandler, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_PerlNodeFilterCallbackHandler[] = { {&_swigt__p_PerlNodeFilterCallbackHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_SecurityManager[] = { {&_swigt__p_SecurityManager, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t[] = { {&_swigt__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__AbstractDOMParser[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser, _p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__BinInputStream[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__BinInputStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMAttr[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMAttr, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMCDATASection[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMCharacterData[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMText, _p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMComment, _p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, _p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMComment[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMComment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMConfiguration[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocument[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentRange[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentRange, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument, _p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMDocumentRange, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument, _p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentType[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMElement[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMElement, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMEntity[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntity, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMEntityReference[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMError[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMError, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMErrorHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMErrorHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMException[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMException, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMRangeException, _p_XERCES_CPP_NAMESPACE__DOMRangeExceptionTo_p_XERCES_CPP_NAMESPACE__DOMException, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSException, _p_XERCES_CPP_NAMESPACE__DOMLSExceptionTo_p_XERCES_CPP_NAMESPACE__DOMException, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementation[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementation, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationLS[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementation, _p_XERCES_CPP_NAMESPACE__DOMImplementationTo_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationList[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationSource[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationSource, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSException[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSException, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSInput[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, _p_XERCES_CPP_NAMESPACE__Wrapper4InputSourceTo_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSInput, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSOutput[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSParser[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSParser, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSParserFilter[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSParserFilter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSSerializer[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLocator[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLocator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNode[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMAttr, _p_XERCES_CPP_NAMESPACE__DOMAttrTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNotation, _p_XERCES_CPP_NAMESPACE__DOMNotationTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMText, _p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, _p_XERCES_CPP_NAMESPACE__DOMDocumentFragmentTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace, _p_XERCES_CPP_NAMESPACE__DOMXPathNamespaceTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, _p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference, _p_XERCES_CPP_NAMESPACE__DOMEntityReferenceTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntity, _p_XERCES_CPP_NAMESPACE__DOMEntityTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData, _p_XERCES_CPP_NAMESPACE__DOMCharacterDataTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType, _p_XERCES_CPP_NAMESPACE__DOMDocumentTypeTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMComment, _p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument, _p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMElement, _p_XERCES_CPP_NAMESPACE__DOMElementTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, _p_XERCES_CPP_NAMESPACE__DOMProcessingInstructionTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeFilter[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, _p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilterTo_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0, 0, 0}, {&_swigt__p_PerlNodeFilterCallbackHandler, _p_PerlNodeFilterCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeIterator[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeList[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNotation[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNotation, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMRange[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMRange, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMRangeException[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMRangeException, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMStringList[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMStringList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMText[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMText, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, _p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMText, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMTreeWalker[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMTypeInfo[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument, _p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathException[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathException, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathExpression[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathExpression, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathResult[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__HandlerBase[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__HandlerBase, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DefaultHandler[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__DefaultHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__EntityResolver[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__EntityResolver, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__HandlerBase, _p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__EntityResolver, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DefaultHandler, _p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__EntityResolver, 0, 0}, {&_swigt__p_PerlEntityResolverHandler, _p_PerlEntityResolverHandlerTo_p_XERCES_CPP_NAMESPACE__EntityResolver, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__ErrorHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__HandlerBase, _p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__ErrorHandler, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DefaultHandler, _p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0, 0}, {&_swigt__p_PerlErrorCallbackHandler, _p_PerlErrorCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DTDGrammar[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__DTDGrammar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SchemaGrammar[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__SchemaGrammar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__Grammar[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__Grammar, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDGrammar, _p_XERCES_CPP_NAMESPACE__DTDGrammarTo_p_XERCES_CPP_NAMESPACE__Grammar, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaGrammar, _p_XERCES_CPP_NAMESPACE__SchemaGrammarTo_p_XERCES_CPP_NAMESPACE__Grammar, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__LocalFileInputSource[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__StdInInputSource[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__URLInputSource[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__URLInputSource, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__MemBufInputSource[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__InputSource[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__InputSource, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource, _p_XERCES_CPP_NAMESPACE__LocalFileInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource, _p_XERCES_CPP_NAMESPACE__StdInInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__URLInputSource, _p_XERCES_CPP_NAMESPACE__URLInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource, _p_XERCES_CPP_NAMESPACE__MemBufInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, _p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInputTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__MemoryManager[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__MemoryManager, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__PSVIHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__AbstractDOMParser, _p_XERCES_CPP_NAMESPACE__AbstractDOMParserTo_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser, _p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__PSVIHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLEntityResolver[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLEntityResolver, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLFormatTarget[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, _p_XERCES_CPP_NAMESPACE__StdOutFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, _p_XERCES_CPP_NAMESPACE__LocalFileFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, _p_XERCES_CPP_NAMESPACE__MemBufFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLFormatter[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLGrammarPool[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarPool, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLPScanToken[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DTDValidator[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__DTDValidator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SchemaValidator[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLValidator[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLValidator, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDValidator, _p_XERCES_CPP_NAMESPACE__DTDValidatorTo_p_XERCES_CPP_NAMESPACE__XMLValidator, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator, _p_XERCES_CPP_NAMESPACE__SchemaValidatorTo_p_XERCES_CPP_NAMESPACE__XMLValidator, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLUri[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLUri, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLSchemaDescription[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLSchemaDescription, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLDTDDescription[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLDTDDescription, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SchemaElementDecl[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__SchemaElementDecl, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DTDElementDecl[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__DTDElementDecl, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLElementDecl[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLElementDecl, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLAttDef[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDef, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DTDAttDef[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SAXParser[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__SAXParser, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLNotationDecl[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SchemaAttDef[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDef, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLURL[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLURL, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLException[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLException, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLContentModel[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLContentModel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SAXException[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__SAXException, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SAXNotSupportedException[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SAXParseException[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__SAXParseException, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__QName[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__QName, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SchemaAttDefList[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDefList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DTDAttDefList[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDefList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLAttDefList[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDefList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DTDEntityDecl[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__DTDEntityDecl, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLEntityDecl[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLEntityDecl, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMemory[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLUri, _p_XERCES_CPP_NAMESPACE__XMLUriTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLSchemaDescription, _p_XERCES_CPP_NAMESPACE__XMLSchemaDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription, _p_XERCES_CPP_NAMESPACE__XMLGrammarDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLDTDDescription, _p_XERCES_CPP_NAMESPACE__XMLDTDDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaElementDecl, _p_XERCES_CPP_NAMESPACE__SchemaElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDElementDecl, _p_XERCES_CPP_NAMESPACE__DTDElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLElementDecl, _p_XERCES_CPP_NAMESPACE__XMLElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator, _p_XERCES_CPP_NAMESPACE__SchemaValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDValidator, _p_XERCES_CPP_NAMESPACE__DTDValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLValidator, _p_XERCES_CPP_NAMESPACE__XMLValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLPScanToken, _p_XERCES_CPP_NAMESPACE__XMLPScanTokenTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, _p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDef, _p_XERCES_CPP_NAMESPACE__XMLAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef, _p_XERCES_CPP_NAMESPACE__DTDAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXParser, _p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl, _p_XERCES_CPP_NAMESPACE__XMLNotationDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatTarget, _p_XERCES_CPP_NAMESPACE__XMLFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, _p_XERCES_CPP_NAMESPACE__StdOutFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, _p_XERCES_CPP_NAMESPACE__LocalFileFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, _p_XERCES_CPP_NAMESPACE__MemBufFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource, _p_XERCES_CPP_NAMESPACE__LocalFileInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__InputSource, _p_XERCES_CPP_NAMESPACE__InputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource, _p_XERCES_CPP_NAMESPACE__StdInInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__URLInputSource, _p_XERCES_CPP_NAMESPACE__URLInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource, _p_XERCES_CPP_NAMESPACE__MemBufInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDef, _p_XERCES_CPP_NAMESPACE__SchemaAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__AbstractDOMParser, _p_XERCES_CPP_NAMESPACE__AbstractDOMParserTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser, _p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLURL, _p_XERCES_CPP_NAMESPACE__XMLURLTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLException, _p_XERCES_CPP_NAMESPACE__XMLExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLContentModel, _p_XERCES_CPP_NAMESPACE__XMLContentModelTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDGrammar, _p_XERCES_CPP_NAMESPACE__DTDGrammarTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaGrammar, _p_XERCES_CPP_NAMESPACE__SchemaGrammarTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__Grammar, _p_XERCES_CPP_NAMESPACE__GrammarTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXException, _p_XERCES_CPP_NAMESPACE__SAXExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, _p_XERCES_CPP_NAMESPACE__SAXNotSupportedExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException, _p_XERCES_CPP_NAMESPACE__SAXNotRecognizedExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXParseException, _p_XERCES_CPP_NAMESPACE__SAXParseExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, _p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMemory, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__QName, _p_XERCES_CPP_NAMESPACE__QNameTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, _p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInputTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDefList, _p_XERCES_CPP_NAMESPACE__SchemaAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDefList, _p_XERCES_CPP_NAMESPACE__DTDAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDefList, _p_XERCES_CPP_NAMESPACE__XMLAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatter, _p_XERCES_CPP_NAMESPACE__XMLFormatterTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDEntityDecl, _p_XERCES_CPP_NAMESPACE__DTDEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLEntityDecl, _p_XERCES_CPP_NAMESPACE__XMLEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XercesDOMParser[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XMLErrorReporter__ErrTypes[] = { {&_swigt__p_XMLErrorReporter__ErrTypes, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int32_t[] = { {&_swigt__p_int32_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ssize_t[] = { {&_swigt__p_ssize_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_uint16_t[] = { {&_swigt__p_uint16_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_uint32_t[] = { {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+ _swigc__p_PSVIAttributeList,
+ _swigc__p_PSVIElement,
+ _swigc__p_PerlCallbackHandler,
+ _swigc__p_PerlContentCallbackHandler,
+ _swigc__p_PerlDocumentCallbackHandler,
+ _swigc__p_PerlEntityResolverHandler,
+ _swigc__p_PerlErrorCallbackHandler,
+ _swigc__p_PerlNodeFilterCallbackHandler,
+ _swigc__p_SecurityManager,
+ _swigc__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__AbstractDOMParser,
+ _swigc__p_XERCES_CPP_NAMESPACE__BinInputStream,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMAttr,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMCDATASection,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMCharacterData,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMComment,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMConfiguration,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMDocument,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentRange,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentType,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMElement,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMEntity,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMEntityReference,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMError,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMErrorHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMException,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementation,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationLS,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationList,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationSource,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMLSException,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMLSInput,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMLSOutput,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMLSParser,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMLSParserFilter,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMLSSerializer,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMLocator,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMNode,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeFilter,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeIterator,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeList,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMNotation,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMRange,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMRangeException,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMStringList,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMText,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMTreeWalker,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMTypeInfo,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathException,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathExpression,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace,
+ _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathResult,
+ _swigc__p_XERCES_CPP_NAMESPACE__DTDAttDef,
+ _swigc__p_XERCES_CPP_NAMESPACE__DTDAttDefList,
+ _swigc__p_XERCES_CPP_NAMESPACE__DTDElementDecl,
+ _swigc__p_XERCES_CPP_NAMESPACE__DTDEntityDecl,
+ _swigc__p_XERCES_CPP_NAMESPACE__DTDGrammar,
+ _swigc__p_XERCES_CPP_NAMESPACE__DTDValidator,
+ _swigc__p_XERCES_CPP_NAMESPACE__DefaultHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__EntityResolver,
+ _swigc__p_XERCES_CPP_NAMESPACE__ErrorHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__Grammar,
+ _swigc__p_XERCES_CPP_NAMESPACE__HandlerBase,
+ _swigc__p_XERCES_CPP_NAMESPACE__InputSource,
+ _swigc__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget,
+ _swigc__p_XERCES_CPP_NAMESPACE__LocalFileInputSource,
+ _swigc__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget,
+ _swigc__p_XERCES_CPP_NAMESPACE__MemBufInputSource,
+ _swigc__p_XERCES_CPP_NAMESPACE__MemoryManager,
+ _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__PSVIHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__QName,
+ _swigc__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__SAXException,
+ _swigc__p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException,
+ _swigc__p_XERCES_CPP_NAMESPACE__SAXNotSupportedException,
+ _swigc__p_XERCES_CPP_NAMESPACE__SAXParseException,
+ _swigc__p_XERCES_CPP_NAMESPACE__SAXParser,
+ _swigc__p_XERCES_CPP_NAMESPACE__SchemaAttDef,
+ _swigc__p_XERCES_CPP_NAMESPACE__SchemaAttDefList,
+ _swigc__p_XERCES_CPP_NAMESPACE__SchemaElementDecl,
+ _swigc__p_XERCES_CPP_NAMESPACE__SchemaGrammar,
+ _swigc__p_XERCES_CPP_NAMESPACE__SchemaValidator,
+ _swigc__p_XERCES_CPP_NAMESPACE__StdInInputSource,
+ _swigc__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget,
+ _swigc__p_XERCES_CPP_NAMESPACE__URLInputSource,
+ _swigc__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput,
+ _swigc__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLAttDef,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLAttDefList,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLContentModel,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLDTDDescription,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLElementDecl,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLEntityDecl,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLEntityResolver,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLException,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLFormatTarget,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLFormatter,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLGrammarPool,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLNotationDecl,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLPScanToken,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLSchemaDescription,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLURL,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLUri,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLValidator,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMemory,
+ _swigc__p_XERCES_CPP_NAMESPACE__XercesDOMParser,
+ _swigc__p_XMLErrorReporter__ErrTypes,
+ _swigc__p_char,
+ _swigc__p_int32_t,
+ _swigc__p_size_t,
+ _swigc__p_ssize_t,
+ _swigc__p_uint16_t,
+ _swigc__p_uint32_t,
+ _swigc__p_unsigned_char,
+ _swigc__p_void,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+static swig_constant_info swig_constants[] = {
+{0,0,0,0,0,0}
+};
+#ifdef __cplusplus
+}
+#endif
+static swig_variable_info swig_variables[] = {
+{0,0,0,0}
+};
+static swig_command_info swig_commands[] = {
+{"XML::Xercesc::new_DOMException", _wrap_new_DOMException},
+{"XML::Xercesc::delete_DOMException", _wrap_delete_DOMException},
+{"XML::Xercesc::DOMException_getMessage", _wrap_DOMException_getMessage},
+{"XML::Xercesc::DOMException_code_set", _wrap_DOMException_code_set},
+{"XML::Xercesc::DOMException_code_get", _wrap_DOMException_code_get},
+{"XML::Xercesc::DOMException_msg_set", _wrap_DOMException_msg_set},
+{"XML::Xercesc::DOMException_msg_get", _wrap_DOMException_msg_get},
+{"XML::Xercesc::delete_DOMNode", _wrap_delete_DOMNode},
+{"XML::Xercesc::DOMNode_getNodeName", _wrap_DOMNode_getNodeName},
+{"XML::Xercesc::DOMNode_getNodeValue", _wrap_DOMNode_getNodeValue},
+{"XML::Xercesc::DOMNode_getNodeType", _wrap_DOMNode_getNodeType},
+{"XML::Xercesc::DOMNode_getParentNode", _wrap_DOMNode_getParentNode},
+{"XML::Xercesc::DOMNode_getChildNodes", _wrap_DOMNode_getChildNodes},
+{"XML::Xercesc::DOMNode_getFirstChild", _wrap_DOMNode_getFirstChild},
+{"XML::Xercesc::DOMNode_getLastChild", _wrap_DOMNode_getLastChild},
+{"XML::Xercesc::DOMNode_getPreviousSibling", _wrap_DOMNode_getPreviousSibling},
+{"XML::Xercesc::DOMNode_getNextSibling", _wrap_DOMNode_getNextSibling},
+{"XML::Xercesc::DOMNode_getAttributes", _wrap_DOMNode_getAttributes},
+{"XML::Xercesc::DOMNode_getOwnerDocument", _wrap_DOMNode_getOwnerDocument},
+{"XML::Xercesc::DOMNode_cloneNode", _wrap_DOMNode_cloneNode},
+{"XML::Xercesc::DOMNode_insertBefore", _wrap_DOMNode_insertBefore},
+{"XML::Xercesc::DOMNode_replaceChild", _wrap_DOMNode_replaceChild},
+{"XML::Xercesc::DOMNode_removeChild", _wrap_DOMNode_removeChild},
+{"XML::Xercesc::DOMNode_appendChild", _wrap_DOMNode_appendChild},
+{"XML::Xercesc::DOMNode_hasChildNodes", _wrap_DOMNode_hasChildNodes},
+{"XML::Xercesc::DOMNode_setNodeValue", _wrap_DOMNode_setNodeValue},
+{"XML::Xercesc::DOMNode_normalize", _wrap_DOMNode_normalize},
+{"XML::Xercesc::DOMNode_isSupported", _wrap_DOMNode_isSupported},
+{"XML::Xercesc::DOMNode_getNamespaceURI", _wrap_DOMNode_getNamespaceURI},
+{"XML::Xercesc::DOMNode_getLocalName", _wrap_DOMNode_getLocalName},
+{"XML::Xercesc::DOMNode_setPrefix", _wrap_DOMNode_setPrefix},
+{"XML::Xercesc::DOMNode_hasAttributes", _wrap_DOMNode_hasAttributes},
+{"XML::Xercesc::DOMNode_isSameNode", _wrap_DOMNode_isSameNode},
+{"XML::Xercesc::DOMNode_isEqualNode", _wrap_DOMNode_isEqualNode},
+{"XML::Xercesc::DOMNode_setUserData", _wrap_DOMNode_setUserData},
+{"XML::Xercesc::DOMNode_getUserData", _wrap_DOMNode_getUserData},
+{"XML::Xercesc::DOMNode_getBaseURI", _wrap_DOMNode_getBaseURI},
+{"XML::Xercesc::DOMNode_compareDocumentPosition", _wrap_DOMNode_compareDocumentPosition},
+{"XML::Xercesc::DOMNode_getTextContent", _wrap_DOMNode_getTextContent},
+{"XML::Xercesc::DOMNode_setTextContent", _wrap_DOMNode_setTextContent},
+{"XML::Xercesc::DOMNode_lookupPrefix", _wrap_DOMNode_lookupPrefix},
+{"XML::Xercesc::DOMNode_isDefaultNamespace", _wrap_DOMNode_isDefaultNamespace},
+{"XML::Xercesc::DOMNode_lookupNamespaceURI", _wrap_DOMNode_lookupNamespaceURI},
+{"XML::Xercesc::DOMNode_getFeature", _wrap_DOMNode_getFeature},
+{"XML::Xercesc::DOMNode_release", _wrap_DOMNode_release},
+{"XML::Xercesc::DOMNode___eq__", _wrap_DOMNode___eq__},
+{"XML::Xercesc::DOMNode___ne__", _wrap_DOMNode___ne__},
+{"XML::Xercesc::delete_DOMAttr", _wrap_delete_DOMAttr},
+{"XML::Xercesc::DOMAttr_getName", _wrap_DOMAttr_getName},
+{"XML::Xercesc::DOMAttr_getSpecified", _wrap_DOMAttr_getSpecified},
+{"XML::Xercesc::DOMAttr_getValue", _wrap_DOMAttr_getValue},
+{"XML::Xercesc::DOMAttr_setValue", _wrap_DOMAttr_setValue},
+{"XML::Xercesc::DOMAttr_getOwnerElement", _wrap_DOMAttr_getOwnerElement},
+{"XML::Xercesc::DOMAttr_isId", _wrap_DOMAttr_isId},
+{"XML::Xercesc::DOMAttr_getSchemaTypeInfo", _wrap_DOMAttr_getSchemaTypeInfo},
+{"XML::Xercesc::delete_DOMElement", _wrap_delete_DOMElement},
+{"XML::Xercesc::DOMElement_getTagName", _wrap_DOMElement_getTagName},
+{"XML::Xercesc::DOMElement_getAttribute", _wrap_DOMElement_getAttribute},
+{"XML::Xercesc::DOMElement_getAttributeNode", _wrap_DOMElement_getAttributeNode},
+{"XML::Xercesc::DOMElement_getElementsByTagName", _wrap_DOMElement_getElementsByTagName},
+{"XML::Xercesc::DOMElement_setAttribute", _wrap_DOMElement_setAttribute},
+{"XML::Xercesc::DOMElement_setAttributeNode", _wrap_DOMElement_setAttributeNode},
+{"XML::Xercesc::DOMElement_removeAttributeNode", _wrap_DOMElement_removeAttributeNode},
+{"XML::Xercesc::DOMElement_removeAttribute", _wrap_DOMElement_removeAttribute},
+{"XML::Xercesc::DOMElement_getAttributeNS", _wrap_DOMElement_getAttributeNS},
+{"XML::Xercesc::DOMElement_setAttributeNS", _wrap_DOMElement_setAttributeNS},
+{"XML::Xercesc::DOMElement_removeAttributeNS", _wrap_DOMElement_removeAttributeNS},
+{"XML::Xercesc::DOMElement_getAttributeNodeNS", _wrap_DOMElement_getAttributeNodeNS},
+{"XML::Xercesc::DOMElement_setAttributeNodeNS", _wrap_DOMElement_setAttributeNodeNS},
+{"XML::Xercesc::DOMElement_getElementsByTagNameNS", _wrap_DOMElement_getElementsByTagNameNS},
+{"XML::Xercesc::DOMElement_hasAttribute", _wrap_DOMElement_hasAttribute},
+{"XML::Xercesc::DOMElement_hasAttributeNS", _wrap_DOMElement_hasAttributeNS},
+{"XML::Xercesc::DOMElement_setIdAttribute", _wrap_DOMElement_setIdAttribute},
+{"XML::Xercesc::DOMElement_setIdAttributeNS", _wrap_DOMElement_setIdAttributeNS},
+{"XML::Xercesc::DOMElement_setIdAttributeNode", _wrap_DOMElement_setIdAttributeNode},
+{"XML::Xercesc::DOMElement_getSchemaTypeInfo", _wrap_DOMElement_getSchemaTypeInfo},
+{"XML::Xercesc::delete_DOMEntity", _wrap_delete_DOMEntity},
+{"XML::Xercesc::DOMEntity_getPublicId", _wrap_DOMEntity_getPublicId},
+{"XML::Xercesc::DOMEntity_getSystemId", _wrap_DOMEntity_getSystemId},
+{"XML::Xercesc::DOMEntity_getNotationName", _wrap_DOMEntity_getNotationName},
+{"XML::Xercesc::DOMEntity_getInputEncoding", _wrap_DOMEntity_getInputEncoding},
+{"XML::Xercesc::DOMEntity_getXmlEncoding", _wrap_DOMEntity_getXmlEncoding},
+{"XML::Xercesc::DOMEntity_getXmlVersion", _wrap_DOMEntity_getXmlVersion},
+{"XML::Xercesc::delete_DOMDocumentType", _wrap_delete_DOMDocumentType},
+{"XML::Xercesc::DOMDocumentType_getName", _wrap_DOMDocumentType_getName},
+{"XML::Xercesc::DOMDocumentType_getEntities", _wrap_DOMDocumentType_getEntities},
+{"XML::Xercesc::DOMDocumentType_getNotations", _wrap_DOMDocumentType_getNotations},
+{"XML::Xercesc::DOMDocumentType_getPublicId", _wrap_DOMDocumentType_getPublicId},
+{"XML::Xercesc::DOMDocumentType_getSystemId", _wrap_DOMDocumentType_getSystemId},
+{"XML::Xercesc::DOMDocumentType_getInternalSubset", _wrap_DOMDocumentType_getInternalSubset},
+{"XML::Xercesc::delete_DOMCharacterData", _wrap_delete_DOMCharacterData},
+{"XML::Xercesc::DOMCharacterData_getData", _wrap_DOMCharacterData_getData},
+{"XML::Xercesc::DOMCharacterData_getLength", _wrap_DOMCharacterData_getLength},
+{"XML::Xercesc::DOMCharacterData_substringData", _wrap_DOMCharacterData_substringData},
+{"XML::Xercesc::DOMCharacterData_appendData", _wrap_DOMCharacterData_appendData},
+{"XML::Xercesc::DOMCharacterData_insertData", _wrap_DOMCharacterData_insertData},
+{"XML::Xercesc::DOMCharacterData_deleteData", _wrap_DOMCharacterData_deleteData},
+{"XML::Xercesc::DOMCharacterData_replaceData", _wrap_DOMCharacterData_replaceData},
+{"XML::Xercesc::DOMCharacterData_setData", _wrap_DOMCharacterData_setData},
+{"XML::Xercesc::delete_DOMComment", _wrap_delete_DOMComment},
+{"XML::Xercesc::delete_DOMText", _wrap_delete_DOMText},
+{"XML::Xercesc::DOMText_splitText", _wrap_DOMText_splitText},
+{"XML::Xercesc::DOMText_getIsElementContentWhitespace", _wrap_DOMText_getIsElementContentWhitespace},
+{"XML::Xercesc::DOMText_getWholeText", _wrap_DOMText_getWholeText},
+{"XML::Xercesc::DOMText_replaceWholeText", _wrap_DOMText_replaceWholeText},
+{"XML::Xercesc::DOMText_isIgnorableWhitespace", _wrap_DOMText_isIgnorableWhitespace},
+{"XML::Xercesc::delete_DOMCDATASection", _wrap_delete_DOMCDATASection},
+{"XML::Xercesc::delete_DOMNodeList", _wrap_delete_DOMNodeList},
+{"XML::Xercesc::DOMNodeList_item", _wrap_DOMNodeList_item},
+{"XML::Xercesc::DOMNodeList_getLength", _wrap_DOMNodeList_getLength},
+{"XML::Xercesc::delete_DOMNamedNodeMap", _wrap_delete_DOMNamedNodeMap},
+{"XML::Xercesc::DOMNamedNodeMap_setNamedItem", _wrap_DOMNamedNodeMap_setNamedItem},
+{"XML::Xercesc::DOMNamedNodeMap_item", _wrap_DOMNamedNodeMap_item},
+{"XML::Xercesc::DOMNamedNodeMap_getNamedItem", _wrap_DOMNamedNodeMap_getNamedItem},
+{"XML::Xercesc::DOMNamedNodeMap_getLength", _wrap_DOMNamedNodeMap_getLength},
+{"XML::Xercesc::DOMNamedNodeMap_removeNamedItem", _wrap_DOMNamedNodeMap_removeNamedItem},
+{"XML::Xercesc::DOMNamedNodeMap_getNamedItemNS", _wrap_DOMNamedNodeMap_getNamedItemNS},
+{"XML::Xercesc::DOMNamedNodeMap_setNamedItemNS", _wrap_DOMNamedNodeMap_setNamedItemNS},
+{"XML::Xercesc::DOMNamedNodeMap_removeNamedItemNS", _wrap_DOMNamedNodeMap_removeNamedItemNS},
+{"XML::Xercesc::delete_DOMDocumentFragment", _wrap_delete_DOMDocumentFragment},
+{"XML::Xercesc::delete_DOMEntityReference", _wrap_delete_DOMEntityReference},
+{"XML::Xercesc::delete_DOMNotation", _wrap_delete_DOMNotation},
+{"XML::Xercesc::DOMNotation_getPublicId", _wrap_DOMNotation_getPublicId},
+{"XML::Xercesc::DOMNotation_getSystemId", _wrap_DOMNotation_getSystemId},
+{"XML::Xercesc::delete_DOMProcessingInstruction", _wrap_delete_DOMProcessingInstruction},
+{"XML::Xercesc::DOMProcessingInstruction_getTarget", _wrap_DOMProcessingInstruction_getTarget},
+{"XML::Xercesc::DOMProcessingInstruction_getData", _wrap_DOMProcessingInstruction_getData},
+{"XML::Xercesc::DOMProcessingInstruction_setData", _wrap_DOMProcessingInstruction_setData},
+{"XML::Xercesc::delete_DOMTypeInfo", _wrap_delete_DOMTypeInfo},
+{"XML::Xercesc::DOMTypeInfo_getTypeName", _wrap_DOMTypeInfo_getTypeName},
+{"XML::Xercesc::DOMTypeInfo_getTypeNamespace", _wrap_DOMTypeInfo_getTypeNamespace},
+{"XML::Xercesc::DOMTypeInfo_isDerivedFrom", _wrap_DOMTypeInfo_isDerivedFrom},
+{"XML::Xercesc::delete_DOMPSVITypeInfo", _wrap_delete_DOMPSVITypeInfo},
+{"XML::Xercesc::DOMPSVITypeInfo_getStringProperty", _wrap_DOMPSVITypeInfo_getStringProperty},
+{"XML::Xercesc::DOMPSVITypeInfo_getNumericProperty", _wrap_DOMPSVITypeInfo_getNumericProperty},
+{"XML::Xercesc::delete_DOMXPathEvaluator", _wrap_delete_DOMXPathEvaluator},
+{"XML::Xercesc::DOMXPathEvaluator_createExpression", _wrap_DOMXPathEvaluator_createExpression},
+{"XML::Xercesc::DOMXPathEvaluator_createNSResolver", _wrap_DOMXPathEvaluator_createNSResolver},
+{"XML::Xercesc::DOMXPathEvaluator_evaluate", _wrap_DOMXPathEvaluator_evaluate},
+{"XML::Xercesc::new_DOMXPathException", _wrap_new_DOMXPathException},
+{"XML::Xercesc::delete_DOMXPathException", _wrap_delete_DOMXPathException},
+{"XML::Xercesc::DOMXPathException_code_set", _wrap_DOMXPathException_code_set},
+{"XML::Xercesc::DOMXPathException_code_get", _wrap_DOMXPathException_code_get},
+{"XML::Xercesc::DOMXPathException_msg_set", _wrap_DOMXPathException_msg_set},
+{"XML::Xercesc::DOMXPathException_msg_get", _wrap_DOMXPathException_msg_get},
+{"XML::Xercesc::delete_DOMXPathExpression", _wrap_delete_DOMXPathExpression},
+{"XML::Xercesc::DOMXPathExpression_evaluate", _wrap_DOMXPathExpression_evaluate},
+{"XML::Xercesc::delete_DOMXPathNamespace", _wrap_delete_DOMXPathNamespace},
+{"XML::Xercesc::DOMXPathNamespace_getOwnerElement", _wrap_DOMXPathNamespace_getOwnerElement},
+{"XML::Xercesc::delete_DOMXPathNSResolver", _wrap_delete_DOMXPathNSResolver},
+{"XML::Xercesc::DOMXPathNSResolver_lookupNamespaceURI", _wrap_DOMXPathNSResolver_lookupNamespaceURI},
+{"XML::Xercesc::DOMXPathNSResolver_lookupPrefix", _wrap_DOMXPathNSResolver_lookupPrefix},
+{"XML::Xercesc::delete_DOMXPathResult", _wrap_delete_DOMXPathResult},
+{"XML::Xercesc::DOMXPathResult_getBooleanValue", _wrap_DOMXPathResult_getBooleanValue},
+{"XML::Xercesc::DOMXPathResult_getInvalidIteratorState", _wrap_DOMXPathResult_getInvalidIteratorState},
+{"XML::Xercesc::DOMXPathResult_getNumberValue", _wrap_DOMXPathResult_getNumberValue},
+{"XML::Xercesc::DOMXPathResult_getResultType", _wrap_DOMXPathResult_getResultType},
+{"XML::Xercesc::DOMXPathResult_getSingleNodeValue", _wrap_DOMXPathResult_getSingleNodeValue},
+{"XML::Xercesc::DOMXPathResult_getSnapshotLength", _wrap_DOMXPathResult_getSnapshotLength},
+{"XML::Xercesc::DOMXPathResult_getStringValue", _wrap_DOMXPathResult_getStringValue},
+{"XML::Xercesc::DOMXPathResult_iterateNext", _wrap_DOMXPathResult_iterateNext},
+{"XML::Xercesc::DOMXPathResult_snapshotItem", _wrap_DOMXPathResult_snapshotItem},
+{"XML::Xercesc::delete_DOMDocumentRange", _wrap_delete_DOMDocumentRange},
+{"XML::Xercesc::DOMDocumentRange_createRange", _wrap_DOMDocumentRange_createRange},
+{"XML::Xercesc::delete_DOMDocumentTraversal", _wrap_delete_DOMDocumentTraversal},
+{"XML::Xercesc::DOMDocumentTraversal_createNodeIterator", _wrap_DOMDocumentTraversal_createNodeIterator},
+{"XML::Xercesc::DOMDocumentTraversal_createTreeWalker", _wrap_DOMDocumentTraversal_createTreeWalker},
+{"XML::Xercesc::delete_DOMNodeIterator", _wrap_delete_DOMNodeIterator},
+{"XML::Xercesc::DOMNodeIterator_getRoot", _wrap_DOMNodeIterator_getRoot},
+{"XML::Xercesc::DOMNodeIterator_getWhatToShow", _wrap_DOMNodeIterator_getWhatToShow},
+{"XML::Xercesc::DOMNodeIterator_getFilter", _wrap_DOMNodeIterator_getFilter},
+{"XML::Xercesc::DOMNodeIterator_getExpandEntityReferences", _wrap_DOMNodeIterator_getExpandEntityReferences},
+{"XML::Xercesc::DOMNodeIterator_nextNode", _wrap_DOMNodeIterator_nextNode},
+{"XML::Xercesc::DOMNodeIterator_previousNode", _wrap_DOMNodeIterator_previousNode},
+{"XML::Xercesc::DOMNodeIterator_detach", _wrap_DOMNodeIterator_detach},
+{"XML::Xercesc::DOMNodeIterator_release", _wrap_DOMNodeIterator_release},
+{"XML::Xercesc::delete_DOMNodeFilter", _wrap_delete_DOMNodeFilter},
+{"XML::Xercesc::DOMNodeFilter_acceptNode", _wrap_DOMNodeFilter_acceptNode},
+{"XML::Xercesc::delete_DOMRange", _wrap_delete_DOMRange},
+{"XML::Xercesc::DOMRange_getStartContainer", _wrap_DOMRange_getStartContainer},
+{"XML::Xercesc::DOMRange_getStartOffset", _wrap_DOMRange_getStartOffset},
+{"XML::Xercesc::DOMRange_getEndContainer", _wrap_DOMRange_getEndContainer},
+{"XML::Xercesc::DOMRange_getEndOffset", _wrap_DOMRange_getEndOffset},
+{"XML::Xercesc::DOMRange_getCollapsed", _wrap_DOMRange_getCollapsed},
+{"XML::Xercesc::DOMRange_getCommonAncestorContainer", _wrap_DOMRange_getCommonAncestorContainer},
+{"XML::Xercesc::DOMRange_setStart", _wrap_DOMRange_setStart},
+{"XML::Xercesc::DOMRange_setEnd", _wrap_DOMRange_setEnd},
+{"XML::Xercesc::DOMRange_setStartBefore", _wrap_DOMRange_setStartBefore},
+{"XML::Xercesc::DOMRange_setStartAfter", _wrap_DOMRange_setStartAfter},
+{"XML::Xercesc::DOMRange_setEndBefore", _wrap_DOMRange_setEndBefore},
+{"XML::Xercesc::DOMRange_setEndAfter", _wrap_DOMRange_setEndAfter},
+{"XML::Xercesc::DOMRange_collapse", _wrap_DOMRange_collapse},
+{"XML::Xercesc::DOMRange_selectNode", _wrap_DOMRange_selectNode},
+{"XML::Xercesc::DOMRange_selectNodeContents", _wrap_DOMRange_selectNodeContents},
+{"XML::Xercesc::DOMRange_compareBoundaryPoints", _wrap_DOMRange_compareBoundaryPoints},
+{"XML::Xercesc::DOMRange_deleteContents", _wrap_DOMRange_deleteContents},
+{"XML::Xercesc::DOMRange_extractContents", _wrap_DOMRange_extractContents},
+{"XML::Xercesc::DOMRange_cloneContents", _wrap_DOMRange_cloneContents},
+{"XML::Xercesc::DOMRange_insertNode", _wrap_DOMRange_insertNode},
+{"XML::Xercesc::DOMRange_surroundContents", _wrap_DOMRange_surroundContents},
+{"XML::Xercesc::DOMRange_cloneRange", _wrap_DOMRange_cloneRange},
+{"XML::Xercesc::DOMRange_toString", _wrap_DOMRange_toString},
+{"XML::Xercesc::DOMRange_detach", _wrap_DOMRange_detach},
+{"XML::Xercesc::DOMRange_release", _wrap_DOMRange_release},
+{"XML::Xercesc::new_DOMRangeException", _wrap_new_DOMRangeException},
+{"XML::Xercesc::delete_DOMRangeException", _wrap_delete_DOMRangeException},
+{"XML::Xercesc::DOMRangeException_code_set", _wrap_DOMRangeException_code_set},
+{"XML::Xercesc::DOMRangeException_code_get", _wrap_DOMRangeException_code_get},
+{"XML::Xercesc::delete_DOMTreeWalker", _wrap_delete_DOMTreeWalker},
+{"XML::Xercesc::DOMTreeWalker_getRoot", _wrap_DOMTreeWalker_getRoot},
+{"XML::Xercesc::DOMTreeWalker_getWhatToShow", _wrap_DOMTreeWalker_getWhatToShow},
+{"XML::Xercesc::DOMTreeWalker_getFilter", _wrap_DOMTreeWalker_getFilter},
+{"XML::Xercesc::DOMTreeWalker_getExpandEntityReferences", _wrap_DOMTreeWalker_getExpandEntityReferences},
+{"XML::Xercesc::DOMTreeWalker_getCurrentNode", _wrap_DOMTreeWalker_getCurrentNode},
+{"XML::Xercesc::DOMTreeWalker_parentNode", _wrap_DOMTreeWalker_parentNode},
+{"XML::Xercesc::DOMTreeWalker_firstChild", _wrap_DOMTreeWalker_firstChild},
+{"XML::Xercesc::DOMTreeWalker_lastChild", _wrap_DOMTreeWalker_lastChild},
+{"XML::Xercesc::DOMTreeWalker_previousSibling", _wrap_DOMTreeWalker_previousSibling},
+{"XML::Xercesc::DOMTreeWalker_nextSibling", _wrap_DOMTreeWalker_nextSibling},
+{"XML::Xercesc::DOMTreeWalker_previousNode", _wrap_DOMTreeWalker_previousNode},
+{"XML::Xercesc::DOMTreeWalker_nextNode", _wrap_DOMTreeWalker_nextNode},
+{"XML::Xercesc::DOMTreeWalker_setCurrentNode", _wrap_DOMTreeWalker_setCurrentNode},
+{"XML::Xercesc::DOMTreeWalker_release", _wrap_DOMTreeWalker_release},
+{"XML::Xercesc::delete_DOMUserDataHandler", _wrap_delete_DOMUserDataHandler},
+{"XML::Xercesc::DOMUserDataHandler_handle", _wrap_DOMUserDataHandler_handle},
+{"XML::Xercesc::DOMConfiguration_setParameter", _wrap_DOMConfiguration_setParameter},
+{"XML::Xercesc::DOMConfiguration_getParameter", _wrap_DOMConfiguration_getParameter},
+{"XML::Xercesc::DOMConfiguration_canSetParameter", _wrap_DOMConfiguration_canSetParameter},
+{"XML::Xercesc::DOMConfiguration_getParameterNames", _wrap_DOMConfiguration_getParameterNames},
+{"XML::Xercesc::delete_DOMConfiguration", _wrap_delete_DOMConfiguration},
+{"XML::Xercesc::delete_DOMStringList", _wrap_delete_DOMStringList},
+{"XML::Xercesc::DOMStringList_item", _wrap_DOMStringList_item},
+{"XML::Xercesc::DOMStringList_getLength", _wrap_DOMStringList_getLength},
+{"XML::Xercesc::DOMStringList_contains", _wrap_DOMStringList_contains},
+{"XML::Xercesc::DOMStringList_release", _wrap_DOMStringList_release},
+{"XML::Xercesc::delete_DOMImplementationLS", _wrap_delete_DOMImplementationLS},
+{"XML::Xercesc::DOMImplementationLS_createLSParser", _wrap_DOMImplementationLS_createLSParser},
+{"XML::Xercesc::DOMImplementationLS_createLSSerializer", _wrap_DOMImplementationLS_createLSSerializer},
+{"XML::Xercesc::DOMImplementationLS_createLSInput", _wrap_DOMImplementationLS_createLSInput},
+{"XML::Xercesc::DOMImplementationLS_createLSOutput", _wrap_DOMImplementationLS_createLSOutput},
+{"XML::Xercesc::delete_DOMImplementation", _wrap_delete_DOMImplementation},
+{"XML::Xercesc::DOMImplementation_hasFeature", _wrap_DOMImplementation_hasFeature},
+{"XML::Xercesc::DOMImplementation_createDocumentType", _wrap_DOMImplementation_createDocumentType},
+{"XML::Xercesc::DOMImplementation_getFeature", _wrap_DOMImplementation_getFeature},
+{"XML::Xercesc::DOMImplementation_createDocument", _wrap_DOMImplementation_createDocument},
+{"XML::Xercesc::DOMImplementation_getImplementation", _wrap_DOMImplementation_getImplementation},
+{"XML::Xercesc::delete_DOMImplementationList", _wrap_delete_DOMImplementationList},
+{"XML::Xercesc::DOMImplementationList_item", _wrap_DOMImplementationList_item},
+{"XML::Xercesc::DOMImplementationList_getLength", _wrap_DOMImplementationList_getLength},
+{"XML::Xercesc::DOMImplementationList_release", _wrap_DOMImplementationList_release},
+{"XML::Xercesc::delete_DOMImplementationSource", _wrap_delete_DOMImplementationSource},
+{"XML::Xercesc::DOMImplementationSource_getDOMImplementation", _wrap_DOMImplementationSource_getDOMImplementation},
+{"XML::Xercesc::DOMImplementationSource_getDOMImplementationList", _wrap_DOMImplementationSource_getDOMImplementationList},
+{"XML::Xercesc::DOMImplementationRegistry_getDOMImplementation", _wrap_DOMImplementationRegistry_getDOMImplementation},
+{"XML::Xercesc::DOMImplementationRegistry_getDOMImplementationList", _wrap_DOMImplementationRegistry_getDOMImplementationList},
+{"XML::Xercesc::DOMImplementationRegistry_addSource", _wrap_DOMImplementationRegistry_addSource},
+{"XML::Xercesc::delete_DOMImplementationRegistry", _wrap_delete_DOMImplementationRegistry},
+{"XML::Xercesc::delete_DOMError", _wrap_delete_DOMError},
+{"XML::Xercesc::DOMError_getSeverity", _wrap_DOMError_getSeverity},
+{"XML::Xercesc::DOMError_getMessage", _wrap_DOMError_getMessage},
+{"XML::Xercesc::DOMError_getLocation", _wrap_DOMError_getLocation},
+{"XML::Xercesc::DOMError_getRelatedException", _wrap_DOMError_getRelatedException},
+{"XML::Xercesc::DOMError_getType", _wrap_DOMError_getType},
+{"XML::Xercesc::DOMError_getRelatedData", _wrap_DOMError_getRelatedData},
+{"XML::Xercesc::delete_DOMErrorHandler", _wrap_delete_DOMErrorHandler},
+{"XML::Xercesc::DOMErrorHandler_handleError", _wrap_DOMErrorHandler_handleError},
+{"XML::Xercesc::delete_DOMDocument", _wrap_delete_DOMDocument},
+{"XML::Xercesc::DOMDocument_createElement", _wrap_DOMDocument_createElement},
+{"XML::Xercesc::DOMDocument_createDocumentFragment", _wrap_DOMDocument_createDocumentFragment},
+{"XML::Xercesc::DOMDocument_createTextNode", _wrap_DOMDocument_createTextNode},
+{"XML::Xercesc::DOMDocument_createComment", _wrap_DOMDocument_createComment},
+{"XML::Xercesc::DOMDocument_createCDATASection", _wrap_DOMDocument_createCDATASection},
+{"XML::Xercesc::DOMDocument_createProcessingInstruction", _wrap_DOMDocument_createProcessingInstruction},
+{"XML::Xercesc::DOMDocument_createAttribute", _wrap_DOMDocument_createAttribute},
+{"XML::Xercesc::DOMDocument_createEntityReference", _wrap_DOMDocument_createEntityReference},
+{"XML::Xercesc::DOMDocument_getDoctype", _wrap_DOMDocument_getDoctype},
+{"XML::Xercesc::DOMDocument_getImplementation", _wrap_DOMDocument_getImplementation},
+{"XML::Xercesc::DOMDocument_getDocumentElement", _wrap_DOMDocument_getDocumentElement},
+{"XML::Xercesc::DOMDocument_getElementsByTagName", _wrap_DOMDocument_getElementsByTagName},
+{"XML::Xercesc::DOMDocument_importNode", _wrap_DOMDocument_importNode},
+{"XML::Xercesc::DOMDocument_createAttributeNS", _wrap_DOMDocument_createAttributeNS},
+{"XML::Xercesc::DOMDocument_getElementsByTagNameNS", _wrap_DOMDocument_getElementsByTagNameNS},
+{"XML::Xercesc::DOMDocument_getElementById", _wrap_DOMDocument_getElementById},
+{"XML::Xercesc::DOMDocument_getInputEncoding", _wrap_DOMDocument_getInputEncoding},
+{"XML::Xercesc::DOMDocument_getXmlEncoding", _wrap_DOMDocument_getXmlEncoding},
+{"XML::Xercesc::DOMDocument_getXmlStandalone", _wrap_DOMDocument_getXmlStandalone},
+{"XML::Xercesc::DOMDocument_setXmlStandalone", _wrap_DOMDocument_setXmlStandalone},
+{"XML::Xercesc::DOMDocument_getXmlVersion", _wrap_DOMDocument_getXmlVersion},
+{"XML::Xercesc::DOMDocument_setXmlVersion", _wrap_DOMDocument_setXmlVersion},
+{"XML::Xercesc::DOMDocument_getDocumentURI", _wrap_DOMDocument_getDocumentURI},
+{"XML::Xercesc::DOMDocument_setDocumentURI", _wrap_DOMDocument_setDocumentURI},
+{"XML::Xercesc::DOMDocument_getStrictErrorChecking", _wrap_DOMDocument_getStrictErrorChecking},
+{"XML::Xercesc::DOMDocument_setStrictErrorChecking", _wrap_DOMDocument_setStrictErrorChecking},
+{"XML::Xercesc::DOMDocument_renameNode", _wrap_DOMDocument_renameNode},
+{"XML::Xercesc::DOMDocument_adoptNode", _wrap_DOMDocument_adoptNode},
+{"XML::Xercesc::DOMDocument_normalizeDocument", _wrap_DOMDocument_normalizeDocument},
+{"XML::Xercesc::DOMDocument_getDOMConfig", _wrap_DOMDocument_getDOMConfig},
+{"XML::Xercesc::DOMDocument_createEntity", _wrap_DOMDocument_createEntity},
+{"XML::Xercesc::DOMDocument_createDocumentType", _wrap_DOMDocument_createDocumentType},
+{"XML::Xercesc::DOMDocument_createNotation", _wrap_DOMDocument_createNotation},
+{"XML::Xercesc::DOMDocument_createElementNS", _wrap_DOMDocument_createElementNS},
+{"XML::Xercesc::delete_DOMLocator", _wrap_delete_DOMLocator},
+{"XML::Xercesc::DOMLocator_getLineNumber", _wrap_DOMLocator_getLineNumber},
+{"XML::Xercesc::DOMLocator_getColumnNumber", _wrap_DOMLocator_getColumnNumber},
+{"XML::Xercesc::DOMLocator_getByteOffset", _wrap_DOMLocator_getByteOffset},
+{"XML::Xercesc::DOMLocator_getUtf16Offset", _wrap_DOMLocator_getUtf16Offset},
+{"XML::Xercesc::DOMLocator_getRelatedNode", _wrap_DOMLocator_getRelatedNode},
+{"XML::Xercesc::DOMLocator_getURI", _wrap_DOMLocator_getURI},
+{"XML::Xercesc::delete_DOMLSResourceResolver", _wrap_delete_DOMLSResourceResolver},
+{"XML::Xercesc::DOMLSResourceResolver_resolveResource", _wrap_DOMLSResourceResolver_resolveResource},
+{"XML::Xercesc::delete_DOMLSInput", _wrap_delete_DOMLSInput},
+{"XML::Xercesc::DOMLSInput_getStringData", _wrap_DOMLSInput_getStringData},
+{"XML::Xercesc::DOMLSInput_getByteStream", _wrap_DOMLSInput_getByteStream},
+{"XML::Xercesc::DOMLSInput_getEncoding", _wrap_DOMLSInput_getEncoding},
+{"XML::Xercesc::DOMLSInput_getPublicId", _wrap_DOMLSInput_getPublicId},
+{"XML::Xercesc::DOMLSInput_getSystemId", _wrap_DOMLSInput_getSystemId},
+{"XML::Xercesc::DOMLSInput_getBaseURI", _wrap_DOMLSInput_getBaseURI},
+{"XML::Xercesc::DOMLSInput_setStringData", _wrap_DOMLSInput_setStringData},
+{"XML::Xercesc::DOMLSInput_setByteStream", _wrap_DOMLSInput_setByteStream},
+{"XML::Xercesc::DOMLSInput_setEncoding", _wrap_DOMLSInput_setEncoding},
+{"XML::Xercesc::DOMLSInput_setPublicId", _wrap_DOMLSInput_setPublicId},
+{"XML::Xercesc::DOMLSInput_setSystemId", _wrap_DOMLSInput_setSystemId},
+{"XML::Xercesc::DOMLSInput_setBaseURI", _wrap_DOMLSInput_setBaseURI},
+{"XML::Xercesc::DOMLSInput_setIssueFatalErrorIfNotFound", _wrap_DOMLSInput_setIssueFatalErrorIfNotFound},
+{"XML::Xercesc::DOMLSInput_getIssueFatalErrorIfNotFound", _wrap_DOMLSInput_getIssueFatalErrorIfNotFound},
+{"XML::Xercesc::DOMLSInput_release", _wrap_DOMLSInput_release},
+{"XML::Xercesc::new_Wrapper4InputSource", _wrap_new_Wrapper4InputSource},
+{"XML::Xercesc::delete_Wrapper4InputSource", _wrap_delete_Wrapper4InputSource},
+{"XML::Xercesc::Wrapper4InputSource_getStringData", _wrap_Wrapper4InputSource_getStringData},
+{"XML::Xercesc::Wrapper4InputSource_getByteStream", _wrap_Wrapper4InputSource_getByteStream},
+{"XML::Xercesc::Wrapper4InputSource_getEncoding", _wrap_Wrapper4InputSource_getEncoding},
+{"XML::Xercesc::Wrapper4InputSource_getPublicId", _wrap_Wrapper4InputSource_getPublicId},
+{"XML::Xercesc::Wrapper4InputSource_getSystemId", _wrap_Wrapper4InputSource_getSystemId},
+{"XML::Xercesc::Wrapper4InputSource_getBaseURI", _wrap_Wrapper4InputSource_getBaseURI},
+{"XML::Xercesc::Wrapper4InputSource_getIssueFatalErrorIfNotFound", _wrap_Wrapper4InputSource_getIssueFatalErrorIfNotFound},
+{"XML::Xercesc::Wrapper4InputSource_setStringData", _wrap_Wrapper4InputSource_setStringData},
+{"XML::Xercesc::Wrapper4InputSource_setByteStream", _wrap_Wrapper4InputSource_setByteStream},
+{"XML::Xercesc::Wrapper4InputSource_setEncoding", _wrap_Wrapper4InputSource_setEncoding},
+{"XML::Xercesc::Wrapper4InputSource_setPublicId", _wrap_Wrapper4InputSource_setPublicId},
+{"XML::Xercesc::Wrapper4InputSource_setSystemId", _wrap_Wrapper4InputSource_setSystemId},
+{"XML::Xercesc::Wrapper4InputSource_setBaseURI", _wrap_Wrapper4InputSource_setBaseURI},
+{"XML::Xercesc::Wrapper4InputSource_setIssueFatalErrorIfNotFound", _wrap_Wrapper4InputSource_setIssueFatalErrorIfNotFound},
+{"XML::Xercesc::Wrapper4InputSource_release", _wrap_Wrapper4InputSource_release},
+{"XML::Xercesc::new_Wrapper4DOMLSInput", _wrap_new_Wrapper4DOMLSInput},
+{"XML::Xercesc::delete_Wrapper4DOMLSInput", _wrap_delete_Wrapper4DOMLSInput},
+{"XML::Xercesc::Wrapper4DOMLSInput_makeStream", _wrap_Wrapper4DOMLSInput_makeStream},
+{"XML::Xercesc::Wrapper4DOMLSInput_getEncoding", _wrap_Wrapper4DOMLSInput_getEncoding},
+{"XML::Xercesc::Wrapper4DOMLSInput_getPublicId", _wrap_Wrapper4DOMLSInput_getPublicId},
+{"XML::Xercesc::Wrapper4DOMLSInput_getSystemId", _wrap_Wrapper4DOMLSInput_getSystemId},
+{"XML::Xercesc::Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound", _wrap_Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound},
+{"XML::Xercesc::Wrapper4DOMLSInput_setEncoding", _wrap_Wrapper4DOMLSInput_setEncoding},
+{"XML::Xercesc::Wrapper4DOMLSInput_setPublicId", _wrap_Wrapper4DOMLSInput_setPublicId},
+{"XML::Xercesc::Wrapper4DOMLSInput_setSystemId", _wrap_Wrapper4DOMLSInput_setSystemId},
+{"XML::Xercesc::Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound", _wrap_Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound},
+{"XML::Xercesc::delete_DOMLSParser", _wrap_delete_DOMLSParser},
+{"XML::Xercesc::DOMLSParser_getDomConfig", _wrap_DOMLSParser_getDomConfig},
+{"XML::Xercesc::DOMLSParser_getAsync", _wrap_DOMLSParser_getAsync},
+{"XML::Xercesc::DOMLSParser_getBusy", _wrap_DOMLSParser_getBusy},
+{"XML::Xercesc::DOMLSParser_setFilter", _wrap_DOMLSParser_setFilter},
+{"XML::Xercesc::DOMLSParser_parse", _wrap_DOMLSParser_parse},
+{"XML::Xercesc::DOMLSParser_parseURI", _wrap_DOMLSParser_parseURI},
+{"XML::Xercesc::DOMLSParser_parseWithContext", _wrap_DOMLSParser_parseWithContext},
+{"XML::Xercesc::DOMLSParser_abort", _wrap_DOMLSParser_abort},
+{"XML::Xercesc::DOMLSParser_release", _wrap_DOMLSParser_release},
+{"XML::Xercesc::DOMLSParser_resetDocumentPool", _wrap_DOMLSParser_resetDocumentPool},
+{"XML::Xercesc::DOMLSParser_loadGrammar", _wrap_DOMLSParser_loadGrammar},
+{"XML::Xercesc::DOMLSParser_getGrammar", _wrap_DOMLSParser_getGrammar},
+{"XML::Xercesc::DOMLSParser_getRootGrammar", _wrap_DOMLSParser_getRootGrammar},
+{"XML::Xercesc::DOMLSParser_getURIText", _wrap_DOMLSParser_getURIText},
+{"XML::Xercesc::DOMLSParser_resetCachedGrammarPool", _wrap_DOMLSParser_resetCachedGrammarPool},
+{"XML::Xercesc::DOMLSParser_getSrcOffset", _wrap_DOMLSParser_getSrcOffset},
+{"XML::Xercesc::delete_DOMLSOutput", _wrap_delete_DOMLSOutput},
+{"XML::Xercesc::DOMLSOutput_getByteStream", _wrap_DOMLSOutput_getByteStream},
+{"XML::Xercesc::DOMLSOutput_getEncoding", _wrap_DOMLSOutput_getEncoding},
+{"XML::Xercesc::DOMLSOutput_getSystemId", _wrap_DOMLSOutput_getSystemId},
+{"XML::Xercesc::DOMLSOutput_setByteStream", _wrap_DOMLSOutput_setByteStream},
+{"XML::Xercesc::DOMLSOutput_setEncoding", _wrap_DOMLSOutput_setEncoding},
+{"XML::Xercesc::DOMLSOutput_setSystemId", _wrap_DOMLSOutput_setSystemId},
+{"XML::Xercesc::DOMLSOutput_release", _wrap_DOMLSOutput_release},
+{"XML::Xercesc::new_StdOutFormatTarget", _wrap_new_StdOutFormatTarget},
+{"XML::Xercesc::delete_StdOutFormatTarget", _wrap_delete_StdOutFormatTarget},
+{"XML::Xercesc::StdOutFormatTarget_writeChars", _wrap_StdOutFormatTarget_writeChars},
+{"XML::Xercesc::StdOutFormatTarget_flush", _wrap_StdOutFormatTarget_flush},
+{"XML::Xercesc::new_LocalFileFormatTarget", _wrap_new_LocalFileFormatTarget},
+{"XML::Xercesc::delete_LocalFileFormatTarget", _wrap_delete_LocalFileFormatTarget},
+{"XML::Xercesc::LocalFileFormatTarget_writeChars", _wrap_LocalFileFormatTarget_writeChars},
+{"XML::Xercesc::LocalFileFormatTarget_flush", _wrap_LocalFileFormatTarget_flush},
+{"XML::Xercesc::new_MemBufFormatTarget", _wrap_new_MemBufFormatTarget},
+{"XML::Xercesc::delete_MemBufFormatTarget", _wrap_delete_MemBufFormatTarget},
+{"XML::Xercesc::MemBufFormatTarget_writeChars", _wrap_MemBufFormatTarget_writeChars},
+{"XML::Xercesc::MemBufFormatTarget_getRawBuffer", _wrap_MemBufFormatTarget_getRawBuffer},
+{"XML::Xercesc::MemBufFormatTarget_getLen", _wrap_MemBufFormatTarget_getLen},
+{"XML::Xercesc::MemBufFormatTarget_reset", _wrap_MemBufFormatTarget_reset},
+{"XML::Xercesc::new_DOMLSException", _wrap_new_DOMLSException},
+{"XML::Xercesc::delete_DOMLSException", _wrap_delete_DOMLSException},
+{"XML::Xercesc::DOMLSException_getMessage", _wrap_DOMLSException_getMessage},
+{"XML::Xercesc::DOMLSException_code_set", _wrap_DOMLSException_code_set},
+{"XML::Xercesc::DOMLSException_code_get", _wrap_DOMLSException_code_get},
+{"XML::Xercesc::DOMLSException_msg_set", _wrap_DOMLSException_msg_set},
+{"XML::Xercesc::DOMLSException_msg_get", _wrap_DOMLSException_msg_get},
+{"XML::Xercesc::delete_DOMLSSerializer", _wrap_delete_DOMLSSerializer},
+{"XML::Xercesc::DOMLSSerializer_getDomConfig", _wrap_DOMLSSerializer_getDomConfig},
+{"XML::Xercesc::DOMLSSerializer_setNewLine", _wrap_DOMLSSerializer_setNewLine},
+{"XML::Xercesc::DOMLSSerializer_setFilter", _wrap_DOMLSSerializer_setFilter},
+{"XML::Xercesc::DOMLSSerializer_getNewLine", _wrap_DOMLSSerializer_getNewLine},
+{"XML::Xercesc::DOMLSSerializer_write", _wrap_DOMLSSerializer_write},
+{"XML::Xercesc::DOMLSSerializer_writeToURI", _wrap_DOMLSSerializer_writeToURI},
+{"XML::Xercesc::DOMLSSerializer_writeToString", _wrap_DOMLSSerializer_writeToString},
+{"XML::Xercesc::DOMLSSerializer_release", _wrap_DOMLSSerializer_release},
+{"XML::Xercesc::delete_DOMLSSerializerFilter", _wrap_delete_DOMLSSerializerFilter},
+{"XML::Xercesc::DOMLSSerializerFilter_acceptNode", _wrap_DOMLSSerializerFilter_acceptNode},
+{"XML::Xercesc::DOMLSSerializerFilter_getWhatToShow", _wrap_DOMLSSerializerFilter_getWhatToShow},
+{"XML::Xercesc::delete_AbstractDOMParser", _wrap_delete_AbstractDOMParser},
+{"XML::Xercesc::AbstractDOMParser_reset", _wrap_AbstractDOMParser_reset},
+{"XML::Xercesc::AbstractDOMParser_adoptDocument", _wrap_AbstractDOMParser_adoptDocument},
+{"XML::Xercesc::AbstractDOMParser_getDocument", _wrap_AbstractDOMParser_getDocument},
+{"XML::Xercesc::AbstractDOMParser_getValidator", _wrap_AbstractDOMParser_getValidator},
+{"XML::Xercesc::AbstractDOMParser_getValidationScheme", _wrap_AbstractDOMParser_getValidationScheme},
+{"XML::Xercesc::AbstractDOMParser_getDoSchema", _wrap_AbstractDOMParser_getDoSchema},
+{"XML::Xercesc::AbstractDOMParser_getValidationSchemaFullChecking", _wrap_AbstractDOMParser_getValidationSchemaFullChecking},
+{"XML::Xercesc::AbstractDOMParser_getIdentityConstraintChecking", _wrap_AbstractDOMParser_getIdentityConstraintChecking},
+{"XML::Xercesc::AbstractDOMParser_getErrorCount", _wrap_AbstractDOMParser_getErrorCount},
+{"XML::Xercesc::AbstractDOMParser_getDoNamespaces", _wrap_AbstractDOMParser_getDoNamespaces},
+{"XML::Xercesc::AbstractDOMParser_getExitOnFirstFatalError", _wrap_AbstractDOMParser_getExitOnFirstFatalError},
+{"XML::Xercesc::AbstractDOMParser_getValidationConstraintFatal", _wrap_AbstractDOMParser_getValidationConstraintFatal},
+{"XML::Xercesc::AbstractDOMParser_getCreateEntityReferenceNodes", _wrap_AbstractDOMParser_getCreateEntityReferenceNodes},
+{"XML::Xercesc::AbstractDOMParser_getIncludeIgnorableWhitespace", _wrap_AbstractDOMParser_getIncludeIgnorableWhitespace},
+{"XML::Xercesc::AbstractDOMParser_getExternalSchemaLocation", _wrap_AbstractDOMParser_getExternalSchemaLocation},
+{"XML::Xercesc::AbstractDOMParser_getExternalNoNamespaceSchemaLocation", _wrap_AbstractDOMParser_getExternalNoNamespaceSchemaLocation},
+{"XML::Xercesc::AbstractDOMParser_getSecurityManager", _wrap_AbstractDOMParser_getSecurityManager},
+{"XML::Xercesc::AbstractDOMParser_getLoadExternalDTD", _wrap_AbstractDOMParser_getLoadExternalDTD},
+{"XML::Xercesc::AbstractDOMParser_getCreateCommentNodes", _wrap_AbstractDOMParser_getCreateCommentNodes},
+{"XML::Xercesc::AbstractDOMParser_getCalculateSrcOfs", _wrap_AbstractDOMParser_getCalculateSrcOfs},
+{"XML::Xercesc::AbstractDOMParser_getStandardUriConformant", _wrap_AbstractDOMParser_getStandardUriConformant},
+{"XML::Xercesc::AbstractDOMParser_getPSVIHandler", _wrap_AbstractDOMParser_getPSVIHandler},
+{"XML::Xercesc::AbstractDOMParser_getCreateSchemaInfo", _wrap_AbstractDOMParser_getCreateSchemaInfo},
+{"XML::Xercesc::AbstractDOMParser_getGenerateSyntheticAnnotations", _wrap_AbstractDOMParser_getGenerateSyntheticAnnotations},
+{"XML::Xercesc::AbstractDOMParser_getValidateAnnotations", _wrap_AbstractDOMParser_getValidateAnnotations},
+{"XML::Xercesc::AbstractDOMParser_getIgnoreAnnotations", _wrap_AbstractDOMParser_getIgnoreAnnotations},
+{"XML::Xercesc::AbstractDOMParser_getDisableDefaultEntityResolution", _wrap_AbstractDOMParser_getDisableDefaultEntityResolution},
+{"XML::Xercesc::AbstractDOMParser_getSkipDTDValidation", _wrap_AbstractDOMParser_getSkipDTDValidation},
+{"XML::Xercesc::AbstractDOMParser_setGenerateSyntheticAnnotations", _wrap_AbstractDOMParser_setGenerateSyntheticAnnotations},
+{"XML::Xercesc::AbstractDOMParser_setValidateAnnotations", _wrap_AbstractDOMParser_setValidateAnnotations},
+{"XML::Xercesc::AbstractDOMParser_setDoNamespaces", _wrap_AbstractDOMParser_setDoNamespaces},
+{"XML::Xercesc::AbstractDOMParser_setExitOnFirstFatalError", _wrap_AbstractDOMParser_setExitOnFirstFatalError},
+{"XML::Xercesc::AbstractDOMParser_setValidationConstraintFatal", _wrap_AbstractDOMParser_setValidationConstraintFatal},
+{"XML::Xercesc::AbstractDOMParser_setCreateEntityReferenceNodes", _wrap_AbstractDOMParser_setCreateEntityReferenceNodes},
+{"XML::Xercesc::AbstractDOMParser_setIncludeIgnorableWhitespace", _wrap_AbstractDOMParser_setIncludeIgnorableWhitespace},
+{"XML::Xercesc::AbstractDOMParser_setValidationScheme", _wrap_AbstractDOMParser_setValidationScheme},
+{"XML::Xercesc::AbstractDOMParser_setDoSchema", _wrap_AbstractDOMParser_setDoSchema},
+{"XML::Xercesc::AbstractDOMParser_setValidationSchemaFullChecking", _wrap_AbstractDOMParser_setValidationSchemaFullChecking},
+{"XML::Xercesc::AbstractDOMParser_setIdentityConstraintChecking", _wrap_AbstractDOMParser_setIdentityConstraintChecking},
+{"XML::Xercesc::AbstractDOMParser_setExternalSchemaLocation", _wrap_AbstractDOMParser_setExternalSchemaLocation},
+{"XML::Xercesc::AbstractDOMParser_setExternalNoNamespaceSchemaLocation", _wrap_AbstractDOMParser_setExternalNoNamespaceSchemaLocation},
+{"XML::Xercesc::AbstractDOMParser_setSecurityManager", _wrap_AbstractDOMParser_setSecurityManager},
+{"XML::Xercesc::AbstractDOMParser_setLoadExternalDTD", _wrap_AbstractDOMParser_setLoadExternalDTD},
+{"XML::Xercesc::AbstractDOMParser_setCreateCommentNodes", _wrap_AbstractDOMParser_setCreateCommentNodes},
+{"XML::Xercesc::AbstractDOMParser_setCalculateSrcOfs", _wrap_AbstractDOMParser_setCalculateSrcOfs},
+{"XML::Xercesc::AbstractDOMParser_setStandardUriConformant", _wrap_AbstractDOMParser_setStandardUriConformant},
+{"XML::Xercesc::AbstractDOMParser_useScanner", _wrap_AbstractDOMParser_useScanner},
+{"XML::Xercesc::AbstractDOMParser_useImplementation", _wrap_AbstractDOMParser_useImplementation},
+{"XML::Xercesc::AbstractDOMParser_setPSVIHandler", _wrap_AbstractDOMParser_setPSVIHandler},
+{"XML::Xercesc::AbstractDOMParser_setCreateSchemaInfo", _wrap_AbstractDOMParser_setCreateSchemaInfo},
+{"XML::Xercesc::AbstractDOMParser_setIgnoreAnnotations", _wrap_AbstractDOMParser_setIgnoreAnnotations},
+{"XML::Xercesc::AbstractDOMParser_setDisableDefaultEntityResolution", _wrap_AbstractDOMParser_setDisableDefaultEntityResolution},
+{"XML::Xercesc::AbstractDOMParser_setSkipDTDValidation", _wrap_AbstractDOMParser_setSkipDTDValidation},
+{"XML::Xercesc::AbstractDOMParser_parse", _wrap_AbstractDOMParser_parse},
+{"XML::Xercesc::AbstractDOMParser_parseFirst", _wrap_AbstractDOMParser_parseFirst},
+{"XML::Xercesc::AbstractDOMParser_parseNext", _wrap_AbstractDOMParser_parseNext},
+{"XML::Xercesc::AbstractDOMParser_parseReset", _wrap_AbstractDOMParser_parseReset},
+{"XML::Xercesc::AbstractDOMParser_handleElementPSVI", _wrap_AbstractDOMParser_handleElementPSVI},
+{"XML::Xercesc::AbstractDOMParser_handlePartialElementPSVI", _wrap_AbstractDOMParser_handlePartialElementPSVI},
+{"XML::Xercesc::AbstractDOMParser_handleAttributesPSVI", _wrap_AbstractDOMParser_handleAttributesPSVI},
+{"XML::Xercesc::new_XercesDOMParser", _wrap_new_XercesDOMParser},
+{"XML::Xercesc::delete_XercesDOMParser", _wrap_delete_XercesDOMParser},
+{"XML::Xercesc::XercesDOMParser_getErrorHandler", _wrap_XercesDOMParser_getErrorHandler},
+{"XML::Xercesc::XercesDOMParser_getEntityResolver", _wrap_XercesDOMParser_getEntityResolver},
+{"XML::Xercesc::XercesDOMParser_getXMLEntityResolver", _wrap_XercesDOMParser_getXMLEntityResolver},
+{"XML::Xercesc::XercesDOMParser_isCachingGrammarFromParse", _wrap_XercesDOMParser_isCachingGrammarFromParse},
+{"XML::Xercesc::XercesDOMParser_isUsingCachedGrammarInParse", _wrap_XercesDOMParser_isUsingCachedGrammarInParse},
+{"XML::Xercesc::XercesDOMParser_getGrammar", _wrap_XercesDOMParser_getGrammar},
+{"XML::Xercesc::XercesDOMParser_getRootGrammar", _wrap_XercesDOMParser_getRootGrammar},
+{"XML::Xercesc::XercesDOMParser_getURIText", _wrap_XercesDOMParser_getURIText},
+{"XML::Xercesc::XercesDOMParser_getSrcOffset", _wrap_XercesDOMParser_getSrcOffset},
+{"XML::Xercesc::XercesDOMParser_getIgnoreCachedDTD", _wrap_XercesDOMParser_getIgnoreCachedDTD},
+{"XML::Xercesc::XercesDOMParser_setErrorHandler", _wrap_XercesDOMParser_setErrorHandler},
+{"XML::Xercesc::XercesDOMParser_setEntityResolver", _wrap_XercesDOMParser_setEntityResolver},
+{"XML::Xercesc::XercesDOMParser_setXMLEntityResolver", _wrap_XercesDOMParser_setXMLEntityResolver},
+{"XML::Xercesc::XercesDOMParser_cacheGrammarFromParse", _wrap_XercesDOMParser_cacheGrammarFromParse},
+{"XML::Xercesc::XercesDOMParser_useCachedGrammarInParse", _wrap_XercesDOMParser_useCachedGrammarInParse},
+{"XML::Xercesc::XercesDOMParser_setIgnoreCachedDTD", _wrap_XercesDOMParser_setIgnoreCachedDTD},
+{"XML::Xercesc::XercesDOMParser_resetDocumentPool", _wrap_XercesDOMParser_resetDocumentPool},
+{"XML::Xercesc::XercesDOMParser_error", _wrap_XercesDOMParser_error},
+{"XML::Xercesc::XercesDOMParser_resetErrors", _wrap_XercesDOMParser_resetErrors},
+{"XML::Xercesc::XercesDOMParser_loadGrammar", _wrap_XercesDOMParser_loadGrammar},
+{"XML::Xercesc::XercesDOMParser_resetCachedGrammarPool", _wrap_XercesDOMParser_resetCachedGrammarPool},
+{"XML::Xercesc::new_PerlNodeFilterCallbackHandler", _wrap_new_PerlNodeFilterCallbackHandler},
+{"XML::Xercesc::delete_PerlNodeFilterCallbackHandler", _wrap_delete_PerlNodeFilterCallbackHandler},
+{"XML::Xercesc::PerlNodeFilterCallbackHandler_type", _wrap_PerlNodeFilterCallbackHandler_type},
+{"XML::Xercesc::PerlNodeFilterCallbackHandler_acceptNode", _wrap_PerlNodeFilterCallbackHandler_acceptNode},
+{0,0}
+};
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned staticly to an initial
+ * array. We just loop though that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ * 1) If the cast->type has already been loaded AND the type we are adding
+ * casting info to has not been loaded (it is in this module), THEN we
+ * replace the cast->type pointer with the type pointer that has already
+ * been loaded.
+ * 2) If BOTH types (the one we are adding casting info to, and the
+ * cast->type) are loaded, THEN the cast info has already been loaded by
+ * the previous module so we just ignore it.
+ * 3) Finally, if cast->type has not already been loaded, then we add that
+ * swig_cast_info to the linked list (because the cast->type) pointer will
+ * be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+ size_t i;
+ swig_module_info *module_head;
+ static int init_run = 0;
+
+ clientdata = clientdata;
+
+ if (init_run) return;
+ init_run = 1;
+
+ /* Initialize the swig_module */
+ swig_module.type_initial = swig_type_initial;
+ swig_module.cast_initial = swig_cast_initial;
+
+ /* Try and load any already created modules */
+ module_head = SWIG_GetModule(clientdata);
+ if (module_head) {
+ swig_module.next = module_head->next;
+ module_head->next = &swig_module;
+ } else {
+ /* This is the first module loaded */
+ swig_module.next = &swig_module;
+ SWIG_SetModule(clientdata, &swig_module);
+ }
+
+ /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+ for (i = 0; i < swig_module.size; ++i) {
+ swig_type_info *type = 0;
+ swig_type_info *ret;
+ swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+ /* if there is another module already loaded */
+ if (swig_module.next != &swig_module) {
+ type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+ }
+ if (type) {
+ /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+ if (swig_module.type_initial[i]->clientdata) {
+ type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+ }
+ } else {
+ type = swig_module.type_initial[i];
+ }
+
+ /* Insert casting types */
+ cast = swig_module.cast_initial[i];
+ while (cast->type) {
+ /* Don't need to add information already in the list */
+ ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+ if (swig_module.next != &swig_module) {
+ ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+ if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+ }
+ if (ret) {
+ if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+ cast->type = ret;
+ ret = 0;
+ } else {
+ /* Check for casting already in the list */
+ swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+ if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+ if (!ocast) ret = 0;
+ }
+ }
+
+ if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+ printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+ if (type->cast) {
+ type->cast->prev = cast;
+ cast->next = type->cast;
+ }
+ type->cast = cast;
+ }
+ cast++;
+ }
+ /* Set entry in modules->types array equal to the type */
+ swig_module.types[i] = type;
+ }
+ swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
+ for (i = 0; i < swig_module.size; ++i) {
+ int j = 0;
+ swig_cast_info *cast = swig_module.cast_initial[i];
+ printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+ while (cast->type) {
+ printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+ cast++;
+ ++j;
+ }
+ printf("---- Total casts: %d\n",j);
+ }
+ printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types. It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+ size_t i;
+ swig_cast_info *equiv;
+ static int init_run = 0;
+
+ if (init_run) return;
+ init_run = 1;
+
+ for (i = 0; i < swig_module.size; i++) {
+ if (swig_module.types[i]->clientdata) {
+ equiv = swig_module.types[i]->cast;
+ while (equiv) {
+ if (!equiv->converter) {
+ if (equiv->type && !equiv->type->clientdata)
+ SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+ }
+ equiv = equiv->next;
+ }
+ }
+ }
+}
+
+#ifdef __cplusplus
+#if 0
+{
+ /* c-mode */
+#endif
+}
+#endif
+
+
+
+#ifdef __cplusplus
+extern "C"
+#endif
+
+XS(SWIG_init) {
+ dXSARGS;
+ int i;
+
+ SWIG_InitializeModule(0);
+
+ /* Install commands */
+ for (i = 0; swig_commands[i].name; i++) {
+ newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
+ }
+
+ /* Install variables */
+ for (i = 0; swig_variables[i].name; i++) {
+ SV *sv;
+ sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2);
+ if (swig_variables[i].type) {
+ SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
+ } else {
+ sv_setiv(sv,(IV) 0);
+ }
+ swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
+ }
+
+ /* Install constant */
+ for (i = 0; swig_constants[i].type; i++) {
+ SV *sv;
+ sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2);
+ switch(swig_constants[i].type) {
+ case SWIG_INT:
+ sv_setiv(sv, (IV) swig_constants[i].lvalue);
+ break;
+ case SWIG_FLOAT:
+ sv_setnv(sv, (double) swig_constants[i].dvalue);
+ break;
+ case SWIG_STRING:
+ sv_setpv(sv, (char *) swig_constants[i].pvalue);
+ break;
+ case SWIG_POINTER:
+ SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
+ break;
+ case SWIG_BINARY:
+ SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
+ break;
+ default:
+ break;
+ }
+ SvREADONLY_on(sv);
+ }
+
+
+ SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode->dcast = (swig_dycast_func) DOMNode_dynamic_cast;
+
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_INDEX_SIZE_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INDEX_SIZE_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_DOMSTRING_SIZE_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::DOMSTRING_SIZE_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_HIERARCHY_REQUEST_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::HIERARCHY_REQUEST_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_WRONG_DOCUMENT_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::WRONG_DOCUMENT_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_INVALID_CHARACTER_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INVALID_CHARACTER_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_NO_DATA_ALLOWED_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::NO_DATA_ALLOWED_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_NO_MODIFICATION_ALLOWED_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::NO_MODIFICATION_ALLOWED_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_NOT_FOUND_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::NOT_FOUND_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_NOT_SUPPORTED_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::NOT_SUPPORTED_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_INUSE_ATTRIBUTE_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INUSE_ATTRIBUTE_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_INVALID_STATE_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INVALID_STATE_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_SYNTAX_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::SYNTAX_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_INVALID_MODIFICATION_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INVALID_MODIFICATION_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_NAMESPACE_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::NAMESPACE_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_INVALID_ACCESS_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INVALID_ACCESS_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_VALIDATION_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::VALIDATION_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMException_TYPE_MISMATCH_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::TYPE_MISMATCH_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, (void*) "XML::Xerces::DOMException");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_ELEMENT_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::ELEMENT_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_ATTRIBUTE_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::ATTRIBUTE_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_TEXT_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::TEXT_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_CDATA_SECTION_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::CDATA_SECTION_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_ENTITY_REFERENCE_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::ENTITY_REFERENCE_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_ENTITY_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::ENTITY_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_PROCESSING_INSTRUCTION_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::PROCESSING_INSTRUCTION_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_COMMENT_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::COMMENT_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_TYPE_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_TYPE_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_FRAGMENT_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_FRAGMENT_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_NOTATION_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::NOTATION_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_DISCONNECTED", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_DISCONNECTED)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_PRECEDING", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_PRECEDING)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_FOLLOWING", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_FOLLOWING)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_CONTAINS", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_CONTAINS)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_CONTAINED_BY", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_CONTAINED_BY)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void*) "XML::Xerces::DOMNode");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, (void*) "XML::Xerces::DOMAttr");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, (void*) "XML::Xerces::DOMElement");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, (void*) "XML::Xerces::DOMEntity");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, (void*) "XML::Xerces::DOMDocumentType");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, (void*) "XML::Xerces::DOMCharacterData");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment, (void*) "XML::Xerces::DOMComment");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, (void*) "XML::Xerces::DOMText");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection, (void*) "XML::Xerces::DOMCDATASection");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, (void*) "XML::Xerces::DOMNodeList");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, (void*) "XML::Xerces::DOMNamedNodeMap");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, (void*) "XML::Xerces::DOMDocumentFragment");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference, (void*) "XML::Xerces::DOMEntityReference");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation, (void*) "XML::Xerces::DOMNotation");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, (void*) "XML::Xerces::DOMProcessingInstruction");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMTypeInfo_DERIVATION_RESTRICTION", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMTypeInfo::DERIVATION_RESTRICTION)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMTypeInfo_DERIVATION_EXTENSION", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMTypeInfo::DERIVATION_EXTENSION)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMTypeInfo_DERIVATION_UNION", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMTypeInfo::DERIVATION_UNION)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMTypeInfo_DERIVATION_LIST", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMTypeInfo::DERIVATION_LIST)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, (void*) "XML::Xerces::DOMTypeInfo");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Validity", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Validity)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Validitation_Attempted", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Validitation_Attempted)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Type_Definition_Type", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Type_Definition_Type)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Type_Definition_Name", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Type_Definition_Name)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Type_Definition_Namespace", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Type_Definition_Namespace)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Type_Definition_Anonymous", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Nil", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Nil)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Member_Type_Definition_Name", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Member_Type_Definition_Name)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Member_Type_Definition_Namespace", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Member_Type_Definition_Namespace)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Member_Type_Definition_Anonymous", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Member_Type_Definition_Anonymous)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Schema_Default", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Schema_Default)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Schema_Normalized_Value", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Schema_Normalized_Value)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Schema_Specified", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Schema_Specified)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo, (void*) "XML::Xerces::DOMPSVITypeInfo");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, (void*) "XML::Xerces::DOMXPathEvaluator");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathException_INVALID_EXPRESSION_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathException::INVALID_EXPRESSION_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathException_TYPE_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathException::TYPE_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, (void*) "XML::Xerces::DOMXPathException");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathExpression, (void*) "XML::Xerces::DOMXPathExpression");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathNamespace_XPATH_NAMESPACE_NODE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathNamespace::XPATH_NAMESPACE_NODE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNamespace, (void*) "XML::Xerces::DOMXPathNamespace");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, (void*) "XML::Xerces::DOMXPathNSResolver");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_ANY_TYPE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::ANY_TYPE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_NUMBER_TYPE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::NUMBER_TYPE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_STRING_TYPE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::STRING_TYPE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_BOOLEAN_TYPE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::BOOLEAN_TYPE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_UNORDERED_NODE_ITERATOR_TYPE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::UNORDERED_NODE_ITERATOR_TYPE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_ORDERED_NODE_ITERATOR_TYPE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::ORDERED_NODE_ITERATOR_TYPE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_UNORDERED_NODE_SNAPSHOT_TYPE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::UNORDERED_NODE_SNAPSHOT_TYPE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_ORDERED_NODE_SNAPSHOT_TYPE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_ANY_UNORDERED_NODE_TYPE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::ANY_UNORDERED_NODE_TYPE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_FIRST_ORDERED_NODE_TYPE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::FIRST_ORDERED_NODE_TYPE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, (void*) "XML::Xerces::DOMXPathResult");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentRange, (void*) "XML::Xerces::DOMDocumentRange");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, (void*) "XML::Xerces::DOMDocumentTraversal");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, (void*) "XML::Xerces::DOMNodeIterator");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_FILTER_ACCEPT", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::FILTER_ACCEPT)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_FILTER_REJECT", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::FILTER_REJECT)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_FILTER_SKIP", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::FILTER_SKIP)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_ALL", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_ALL)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_ELEMENT", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_ELEMENT)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_ATTRIBUTE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_ATTRIBUTE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_TEXT", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_TEXT)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_CDATA_SECTION", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_CDATA_SECTION)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_ENTITY_REFERENCE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_ENTITY_REFERENCE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_ENTITY", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_ENTITY)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_PROCESSING_INSTRUCTION", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_PROCESSING_INSTRUCTION)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_COMMENT", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_COMMENT)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_DOCUMENT", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_DOCUMENT)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_DOCUMENT_TYPE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_DOCUMENT_TYPE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_DOCUMENT_FRAGMENT", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_DOCUMENT_FRAGMENT)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_NOTATION", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_NOTATION)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, (void*) "XML::Xerces::DOMNodeFilter");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMRange_START_TO_START", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRange::START_TO_START)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMRange_START_TO_END", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRange::START_TO_END)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMRange_END_TO_END", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRange::END_TO_END)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMRange_END_TO_START", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRange::END_TO_START)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, (void*) "XML::Xerces::DOMRange");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMRangeException_BAD_BOUNDARYPOINTS_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRangeException::BAD_BOUNDARYPOINTS_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMRangeException_INVALID_NODE_TYPE_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRangeException::INVALID_NODE_TYPE_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException, (void*) "XML::Xerces::DOMRangeException");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, (void*) "XML::Xerces::DOMTreeWalker");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMUserDataHandler_NODE_CLONED", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMUserDataHandler::NODE_CLONED)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMUserDataHandler_NODE_IMPORTED", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMUserDataHandler::NODE_IMPORTED)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMUserDataHandler_NODE_DELETED", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMUserDataHandler::NODE_DELETED)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMUserDataHandler_NODE_RENAMED", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMUserDataHandler::NODE_RENAMED)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMUserDataHandler_NODE_ADOPTED", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMUserDataHandler::NODE_ADOPTED)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler, (void*) "XML::Xerces::DOMUserDataHandler");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, (void*) "XML::Xerces::DOMConfiguration");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, (void*) "XML::Xerces::DOMStringList");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMImplementationLS_MODE_SYNCHRONOUS", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMImplementationLS::MODE_SYNCHRONOUS)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMImplementationLS_MODE_ASYNCHRONOUS", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMImplementationLS::MODE_ASYNCHRONOUS)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, (void*) "XML::Xerces::DOMImplementationLS");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, (void*) "XML::Xerces::DOMImplementation");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, (void*) "XML::Xerces::DOMImplementationList");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource, (void*) "XML::Xerces::DOMImplementationSource");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry, (void*) "XML::Xerces::DOMImplementationRegistry");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMError_DOM_SEVERITY_WARNING", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMError::DOM_SEVERITY_WARNING)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMError_DOM_SEVERITY_ERROR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMError::DOM_SEVERITY_ERROR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMError_DOM_SEVERITY_FATAL_ERROR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMError::DOM_SEVERITY_FATAL_ERROR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, (void*) "XML::Xerces::DOMError");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMErrorHandler, (void*) "XML::Xerces::DOMErrorHandler");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, (void*) "XML::Xerces::DOMDocument");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, (void*) "XML::Xerces::DOMLocator");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, (void*) "XML::Xerces::DOMLSResourceResolver");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, (void*) "XML::Xerces::DOMLSInput");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, (void*) "XML::Xerces::Wrapper4InputSource");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, (void*) "XML::Xerces::Wrapper4DOMLSInput");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMLSParser_ACTION_APPEND_AS_CHILDREN", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSParser::ACTION_APPEND_AS_CHILDREN)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMLSParser_ACTION_REPLACE_CHILDREN", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSParser::ACTION_REPLACE_CHILDREN)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMLSParser_ACTION_INSERT_BEFORE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSParser::ACTION_INSERT_BEFORE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMLSParser_ACTION_INSERT_AFTER", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSParser::ACTION_INSERT_AFTER)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMLSParser_ACTION_REPLACE", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSParser::ACTION_REPLACE)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, (void*) "XML::Xerces::DOMLSParser");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, (void*) "XML::Xerces::DOMLSOutput");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, (void*) "XML::Xerces::StdOutFormatTarget");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, (void*) "XML::Xerces::LocalFileFormatTarget");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, (void*) "XML::Xerces::MemBufFormatTarget");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMLSException_PARSE_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSException::PARSE_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "DOMLSException_SERIALIZE_ERR", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSException::SERIALIZE_ERR)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, (void*) "XML::Xerces::DOMLSException");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, (void*) "XML::Xerces::DOMLSSerializer");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, (void*) "XML::Xerces::DOMLSSerializerFilter");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "AbstractDOMParser_Val_Never", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::AbstractDOMParser::Val_Never)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "AbstractDOMParser_Val_Always", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::AbstractDOMParser::Val_Always)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "AbstractDOMParser_Val_Auto", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::AbstractDOMParser::Val_Auto)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, (void*) "XML::Xerces::AbstractDOMParser");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, (void*) "XML::Xerces::XercesDOMParser");
+
+ // we create the global transcoder for UTF-8 to UTF-16
+ // must initialize the Xerces-C transcoding service
+ XMLPlatformUtils::Initialize();
+ UTF8_TRANSCODER = Transcoder::getInstance();
+ if (! UTF8_TRANSCODER) {
+ croak("ERROR: XML::Xerces: INIT: Could not create UTF-8 transcoder");
+ }
+
+ XML_EXCEPTION_HANDLER = XMLExceptionHandler::getInstance();
+ if (! XML_EXCEPTION_HANDLER) {
+ croak("ERROR: XML::Xerces: INIT: Could not create XMLExceptionHandler");
+ }
+
+ SWIG_TypeClientData(SWIGTYPE_p_PerlNodeFilterCallbackHandler, (void*) "XML::Xerces::PerlNodeFilterCallbackHandler");
+ ST(0) = &PL_sv_yes;
+ XSRETURN(1);
+}
+
diff --git a/swig/perl/Handler/Makefile.PL b/swig/perl/Handler/Makefile.PL
index 1e9d5cba8..a3b4760a4 100644
--- a/swig/perl/Handler/Makefile.PL
+++ b/swig/perl/Handler/Makefile.PL
@@ -26,24 +26,3 @@ WriteMakefile(
@LDFLAGS,
);
-__END__
-sub MY::static
-{
- '
-static :: libhandler$(LIB_EXT)
-
-dynamic :: static
-
-libhandler$(LIB_EXT): $(O_FILES) $(MYEXTLIB)
- $(AR) cru libhandler$(LIB_EXT) $(O_FILES)
- $(RANLIB) libhandler$(LIB_EXT)
-
-libhandler.$(DLEXT): $(LDFROM) $(MYEXTLIB)
- $(LD) -o libhandler.$(DLEXT) $(LDDLFLAGS) --whole-archive $(LDFROM) $(OTHERLDFLAGS) $(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) $(EXPORT_LIST)
- $(CHMOD) 755 libhandler.$(DLEXT)
-
-';
-
-}
-
-
diff --git a/swig/perl/Handler/PerlCallbackHandler.cpp b/swig/perl/Handler/PerlCallbackHandler.cpp
index 591a66d4b..28bc178c5 100644
--- a/swig/perl/Handler/PerlCallbackHandler.cpp
+++ b/swig/perl/Handler/PerlCallbackHandler.cpp
@@ -17,36 +17,24 @@
#include <stdlib.h>
#include "PerlCallbackHandler.hpp"
-XMLTranscoder* UTF8_TRANSCODER = NULL;
-
PerlCallbackHandler::PerlCallbackHandler() {
- if (UTF8_TRANSCODER == NULL)
- {
- XMLTransService::Codes failReason;
- XMLCh* UTF8_ENCODING = XMLString::transcode("UTF-8");
- UTF8_TRANSCODER =
- XMLPlatformUtils::fgTransService->makeNewTranscoderFor(UTF8_ENCODING,
- failReason,
- 1024,
- XMLPlatformUtils::fgMemoryManager);
- if (UTF8_TRANSCODER == NULL) {
- croak("ERROR: PerlCallbackHandler Could not create UTF-8 transcoder");
- }
- }
- callbackObj = NULL;
-// printf("PerlCallback: constructor");
+ // fprintf(stderr,"PerlCallback: constructor\n");
+ UTF8_TRANSCODER = Transcoder::getInstance();
+ callbackObj = NULL;
}
PerlCallbackHandler::~PerlCallbackHandler() {
- if (callbackObj) {
- SvREFCNT_dec(callbackObj);
- callbackObj = NULL;
- }
-// printf("PerlCallback: destructor");
+ if (callbackObj) {
+ SvREFCNT_dec(callbackObj);
+ callbackObj = NULL;
+ }
+ if (UTF8_TRANSCODER) {
+ UTF8_TRANSCODER = NULL;
+ }
+ // fprintf(stderr,"PerlCallback: destructor\n");
}
PerlCallbackHandler::PerlCallbackHandler(SV* object)
- : callbackObj(NULL)
{
set_callback_obj(object);
}
@@ -72,30 +60,3 @@ PerlCallbackHandler::set_callback_obj(SV* object) {
// printf("<new callback object 0x%.4X>\n", callbackObj);
return oldRef;
}
-
-SV*
-PerlCallbackHandler::XMLString2Perl(const XMLCh* input) {
- SV *output;
- unsigned int charsEaten = 0;
- int length = XMLString::stringLen(input); // string length
- // use +1 to make room for the '\0' at the end of the string
- // in the pathological case when each character of the string
- // is UTF8_MAXLEN bytes long
- XMLByte* res = new XMLByte[(length * UTF8_MAXLEN) + 1]; // output string
-
- unsigned int total_chars =
- UTF8_TRANSCODER->transcodeTo((const XMLCh*) input,
- (unsigned int) length,
- (XMLByte*) res,
- (unsigned int) (length*UTF8_MAXLEN),
- charsEaten,
- XMLTranscoder::UnRep_Throw
- );
- res[total_chars] = '\0';
-
- output = sv_newmortal();
- sv_setpv((SV*)output, (char *)res );
- SvUTF8_on((SV*)output);
- delete[] res;
- return output;
-}
diff --git a/swig/perl/Handler/PerlCallbackHandler.hpp b/swig/perl/Handler/PerlCallbackHandler.hpp
index 6c9c54fc9..f2a2386b6 100644
--- a/swig/perl/Handler/PerlCallbackHandler.hpp
+++ b/swig/perl/Handler/PerlCallbackHandler.hpp
@@ -17,13 +17,14 @@
#ifndef __PERLCALLBACKHANDLER
#define __PERLCALLBACKHANDLER
-#ifdef __cplusplus
+
/* Needed on some windows machines---since MS plays funny
games with the header files under C++ */
#include <math.h>
#include <stdlib.h>
+
extern "C" {
-#endif
+
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
@@ -33,9 +34,7 @@ extern "C" {
#undef malloc
#include <string.h>
-#ifdef __cplusplus
}
-#endif
#if !defined(PERL_REVISION) || ((PERL_REVISION >= 5) && ((PERL_VERSION < 5) || ((PERL_VERSION == 5) && (PERL_SUBVERSION < 50))))
#ifndef PL_sv_yes
@@ -56,9 +55,8 @@ extern "C" {
#define PERLCALLBACKHANDLER_CONTENT_TYPE 3
#define PERLCALLBACKHANDLER_DOCUMENT_TYPE 4
-#include "xercesc/util/TransService.hpp"
-#include "xercesc/util/XMLString.hpp"
#include "xercesc/util/PlatformUtils.hpp"
+#include "Transcoder.hpp"
XERCES_CPP_NAMESPACE_USE
@@ -70,7 +68,8 @@ private:
protected:
- SV *callbackObj;
+ SV *callbackObj;
+ Transcoder* UTF8_TRANSCODER;
public:
@@ -80,7 +79,6 @@ public:
virtual int type() {return PERLCALLBACKHANDLER_BASE_TYPE;}
SV* set_callback_obj(SV*);
- SV* XMLString2Perl(const XMLCh*);
};
#endif /* __PERLCALLBACKHANDLER */
diff --git a/swig/perl/Handler/PerlContentCallbackHandler.cpp b/swig/perl/Handler/PerlContentCallbackHandler.cpp
index 1350bb594..7ca123f13 100644
--- a/swig/perl/Handler/PerlContentCallbackHandler.cpp
+++ b/swig/perl/Handler/PerlContentCallbackHandler.cpp
@@ -26,22 +26,9 @@ PerlContentCallbackHandler::~PerlContentCallbackHandler()
{}
PerlContentCallbackHandler::PerlContentCallbackHandler(SV *obj)
- : PerlCallbackHandler(obj)
-{}
-
-// SV*
-// PerlContentCallbackHandler::set_callback_obj(SV* object) {
-// SV *oldRef = &PL_sv_undef; // default to 'undef'
-// if (callbackObj != NULL) {
-// oldRef = callbackObj;
-// #if defined(PERL_VERSION) && PERL_VERSION >= 8
-// // SvREFCNT_dec(oldRef);
-// #endif
-// }
-// SvREFCNT_inc(object);
-// callbackObj = object;
-// return oldRef;
-// }
+{
+ set_callback_obj(obj);
+}
void
PerlContentCallbackHandler::startElement(const XMLCh* const uri,
@@ -61,15 +48,15 @@ PerlContentCallbackHandler::startElement(const XMLCh* const uri,
XPUSHs(callbackObj);
// the next argument is the uri
- SV *string1 = XMLString2Perl(uri);
+ SV *string1 = UTF8_TRANSCODER->XMLString2Perl(uri);
XPUSHs(string1);
// the next argument is the localname
- SV *string2 = XMLString2Perl(localname);
+ SV *string2 = UTF8_TRANSCODER->XMLString2Perl(localname);
XPUSHs(string2);
// the next argument is the qname
- SV *string3 = XMLString2Perl(qname);
+ SV *string3 = UTF8_TRANSCODER->XMLString2Perl(qname);
XPUSHs(string3);
// next is the attributes
@@ -102,15 +89,15 @@ PerlContentCallbackHandler::endElement(const XMLCh* const uri,
XPUSHs(callbackObj);
// the next argument is the uri
- SV *string1 = XMLString2Perl(uri);
+ SV *string1 = UTF8_TRANSCODER->XMLString2Perl(uri);
XPUSHs(string1);
// the next argument is the localname
- SV *string2 = XMLString2Perl(localname);
+ SV *string2 = UTF8_TRANSCODER->XMLString2Perl(localname);
XPUSHs(string2);
// the next argument is the qname
- SV *string3 = XMLString2Perl(qname);
+ SV *string3 = UTF8_TRANSCODER->XMLString2Perl(qname);
XPUSHs(string3);
PUTBACK;
@@ -137,7 +124,7 @@ PerlContentCallbackHandler::characters(const XMLCh* const chars,
XPUSHs(callbackObj);
// the next argument is the char data
- SV *string = XMLString2Perl(chars);
+ SV *string = UTF8_TRANSCODER->XMLString2Perl(chars);
XPUSHs(string);
// next is the length
@@ -166,7 +153,7 @@ PerlContentCallbackHandler::ignorableWhitespace(const XMLCh* const chars,
XPUSHs(callbackObj);
// the next argument is the char data
- SV *string = XMLString2Perl(chars);
+ SV *string = UTF8_TRANSCODER->XMLString2Perl(chars);
XPUSHs(string);
// next is the length
@@ -264,11 +251,11 @@ PerlContentCallbackHandler::processingInstruction(const XMLCh* const target,
XPUSHs(callbackObj);
// the next argument is the target
- SV *string1 = XMLString2Perl(target);
+ SV *string1 = UTF8_TRANSCODER->XMLString2Perl(target);
XPUSHs(string1);
// the next argument is the data
- SV *string2 = XMLString2Perl(data);
+ SV *string2 = UTF8_TRANSCODER->XMLString2Perl(data);
XPUSHs(string2);
PUTBACK;
@@ -323,11 +310,11 @@ PerlContentCallbackHandler::startPrefixMapping (const XMLCh* const prefix,
XPUSHs(callbackObj);
// the next argument is the prefix
- SV *string1 = XMLString2Perl(prefix);
+ SV *string1 = UTF8_TRANSCODER->XMLString2Perl(prefix);
XPUSHs(string1);
// the next argument is the uri
- SV *string2 = XMLString2Perl(uri);
+ SV *string2 = UTF8_TRANSCODER->XMLString2Perl(uri);
XPUSHs(string2);
PUTBACK;
@@ -353,7 +340,7 @@ PerlContentCallbackHandler::endPrefixMapping (const XMLCh* const prefix)
XPUSHs(callbackObj);
// the next argument is the prefix
- SV *string1 = XMLString2Perl(prefix);
+ SV *string1 = UTF8_TRANSCODER->XMLString2Perl(prefix);
XPUSHs(string1);
PUTBACK;
@@ -379,7 +366,7 @@ PerlContentCallbackHandler::skippedEntity (const XMLCh* const name)
XPUSHs(callbackObj);
// the next argument is the name
- SV *string1 = XMLString2Perl(name);
+ SV *string1 = UTF8_TRANSCODER->XMLString2Perl(name);
XPUSHs(string1);
PUTBACK;
diff --git a/swig/perl/Handler/PerlDocumentCallbackHandler.cpp b/swig/perl/Handler/PerlDocumentCallbackHandler.cpp
index c3b7cb759..33d5b33e7 100644
--- a/swig/perl/Handler/PerlDocumentCallbackHandler.cpp
+++ b/swig/perl/Handler/PerlDocumentCallbackHandler.cpp
@@ -23,12 +23,7 @@ PerlDocumentCallbackHandler::PerlDocumentCallbackHandler()
}
PerlDocumentCallbackHandler::~PerlDocumentCallbackHandler()
-{
- if (callbackObj != NULL) {
- SvREFCNT_dec(callbackObj);
- callbackObj = NULL;
- }
-}
+{}
PerlDocumentCallbackHandler::PerlDocumentCallbackHandler(SV *obj)
{
@@ -64,7 +59,7 @@ PerlDocumentCallbackHandler::startElement(const XMLCh* const name,
XPUSHs(callbackObj);
// the next argument is the element name
- SV *string = XMLString2Perl(name);
+ SV *string = UTF8_TRANSCODER->XMLString2Perl(name);
XPUSHs(string);
// next is the attribute list
@@ -96,7 +91,7 @@ PerlDocumentCallbackHandler::endElement(const XMLCh* const name)
XPUSHs(callbackObj);
// the next argument is the element name
- SV *string = XMLString2Perl(name);
+ SV *string = UTF8_TRANSCODER->XMLString2Perl(name);
XPUSHs(string);
PUTBACK;
@@ -123,7 +118,7 @@ PerlDocumentCallbackHandler::characters(const XMLCh* const chars,
XPUSHs(callbackObj);
// the next argument is the char data
- SV *string = XMLString2Perl(chars);
+ SV *string = UTF8_TRANSCODER->XMLString2Perl(chars);
XPUSHs(string);
// next is the length
@@ -152,7 +147,7 @@ PerlDocumentCallbackHandler::ignorableWhitespace(const XMLCh* const chars,
XPUSHs(callbackObj);
// the next argument is the element name
- SV *string = XMLString2Perl(chars);
+ SV *string = UTF8_TRANSCODER->XMLString2Perl(chars);
XPUSHs(string);
// next is the length
@@ -250,11 +245,11 @@ PerlDocumentCallbackHandler::processingInstruction(const XMLCh* const target,
XPUSHs(callbackObj);
// the next argument is the target
- SV *string1 = XMLString2Perl(target);
+ SV *string1 = UTF8_TRANSCODER->XMLString2Perl(target);
XPUSHs(string1);
// the next argument is the data
- SV *string2 = XMLString2Perl(data);
+ SV *string2 = UTF8_TRANSCODER->XMLString2Perl(data);
XPUSHs(string2);
PUTBACK;
diff --git a/swig/perl/Handler/PerlEntityResolverHandler.i b/swig/perl/Handler/PerlEntityResolverHandler.cpp
similarity index 72%
rename from swig/perl/Handler/PerlEntityResolverHandler.i
rename to swig/perl/Handler/PerlEntityResolverHandler.cpp
index 826b8b67c..8432dae5b 100644
--- a/swig/perl/Handler/PerlEntityResolverHandler.i
+++ b/swig/perl/Handler/PerlEntityResolverHandler.cpp
@@ -16,6 +16,7 @@
#include "xercesc/sax/InputSource.hpp"
#include "PerlEntityResolverHandler.hpp"
+#include "xerces-swig-perl.hpp"
PerlEntityResolverHandler::PerlEntityResolverHandler()
{
@@ -23,12 +24,7 @@ PerlEntityResolverHandler::PerlEntityResolverHandler()
}
PerlEntityResolverHandler::~PerlEntityResolverHandler()
-{
- if (callbackObj != NULL) {
- SvREFCNT_dec(callbackObj);
- callbackObj = NULL;
- }
-}
+{}
PerlEntityResolverHandler::PerlEntityResolverHandler(SV *obj)
{
@@ -41,20 +37,6 @@ PerlEntityResolverHandler::PerlEntityResolverHandler(SV *obj)
set_callback_obj(obj);
}
-// SV*
-// PerlEntityResolverHandler::set_callback_obj(SV* object) {
-// SV *oldRef = &PL_sv_undef; // default to 'undef'
-// if (callbackObj != NULL) {
-// oldRef = callbackObj;
-// #if defined(PERL_VERSION) && PERL_VERSION >= 8
-// // SvREFCNT_dec(oldRef);
-// #endif
-// }
-// SvREFCNT_inc(object);
-// callbackObj = object;
-// return oldRef;
-// }
-
InputSource *
PerlEntityResolverHandler::resolveEntity (const XMLCh* const publicId,
const XMLCh* const systemId)
@@ -66,6 +48,7 @@ PerlEntityResolverHandler::resolveEntity (const XMLCh* const publicId,
dSP;
InputSource *source;
+ char *isName = "XML::Xerces::InputSource";
ENTER;
SAVETMPS;
@@ -75,11 +58,11 @@ PerlEntityResolverHandler::resolveEntity (const XMLCh* const publicId,
XPUSHs(callbackObj);
// the next argument is the publicId
- SV *string1 = XMLString2Perl(publicId);
+ SV *string1 = UTF8_TRANSCODER->XMLString2Perl(publicId);
XPUSHs(string1);
// the next argument is the systemId
- SV *string2 = XMLString2Perl(systemId);
+ SV *string2 = UTF8_TRANSCODER->XMLString2Perl(systemId);
XPUSHs(string2);
PUTBACK;
@@ -99,13 +82,16 @@ PerlEntityResolverHandler::resolveEntity (const XMLCh* const publicId,
source_sv = POPs;
}
- if (count == 1 && SvOK(source_sv) && !sv_derived_from(source_sv,"XML::Xerces::InputSource")) {
+ if (count == 1
+ && SvOK(source_sv)
+ && !sv_derived_from(source_sv, isName)) {
croak("EntityResolver did not return an InputSource\n") ;
}
- if (SWIG_ConvertPtr(source_sv,(void **) &source, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource,0) < 0) {
-
- croak("EntityResolver did not return an InputSource. Expected %s", SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource->name);
+ // god bless John Lenz's new type system in SWIG 1.3.25!!!
+ swig_type_info *isType = SWIG_TypeQuery(isName);
+ if (SWIG_ConvertPtr(source_sv,(void **) &source, isType, 0) < 0) {
+ croak("EntityResolver did not return an InputSource. Expected %s", isName);
}
PUTBACK ;
FREETMPS;
diff --git a/swig/perl/Handler/PerlErrorCallbackHandler.cpp b/swig/perl/Handler/PerlErrorCallbackHandler.cpp
index 29ccc3b7f..2846c735f 100644
--- a/swig/perl/Handler/PerlErrorCallbackHandler.cpp
+++ b/swig/perl/Handler/PerlErrorCallbackHandler.cpp
@@ -23,32 +23,13 @@ PerlErrorCallbackHandler::PerlErrorCallbackHandler()
}
PerlErrorCallbackHandler::~PerlErrorCallbackHandler()
-{
- if (callbackObj != NULL) {
- SvREFCNT_dec(callbackObj);
- callbackObj = NULL;
- }
-}
+{}
PerlErrorCallbackHandler::PerlErrorCallbackHandler(SV *obj)
{
set_callback_obj(obj);
}
-// SV*
-// PerlErrorCallbackHandler::set_callback_obj(SV* object) {
-// SV *oldRef = &PL_sv_undef; // default to 'undef'
-// if (callbackObj != NULL) {
-// oldRef = callbackObj;
-// #if defined(PERL_VERSION) && PERL_VERSION >= 8
-// // SvREFCNT_dec(oldRef);
-// #endif
-// }
-// SvREFCNT_inc(object);
-// callbackObj = object;
-// return oldRef;
-// }
-
void
PerlErrorCallbackHandler::warning(const SAXParseException& exception) {
diff --git a/swig/perl/Handler/PerlNodeFilterCallbackHandler.i b/swig/perl/Handler/PerlNodeFilterCallbackHandler.cpp
similarity index 72%
rename from swig/perl/Handler/PerlNodeFilterCallbackHandler.i
rename to swig/perl/Handler/PerlNodeFilterCallbackHandler.cpp
index dfcd91c1c..d54449633 100644
--- a/swig/perl/Handler/PerlNodeFilterCallbackHandler.i
+++ b/swig/perl/Handler/PerlNodeFilterCallbackHandler.cpp
@@ -15,6 +15,7 @@
*/
#include "PerlNodeFilterCallbackHandler.hpp"
+#include "xerces-swig-perl.hpp"
PerlNodeFilterCallbackHandler::PerlNodeFilterCallbackHandler()
{
@@ -22,32 +23,13 @@ PerlNodeFilterCallbackHandler::PerlNodeFilterCallbackHandler()
}
PerlNodeFilterCallbackHandler::~PerlNodeFilterCallbackHandler()
-{
- if (callbackObj != NULL) {
- SvREFCNT_dec(callbackObj);
- callbackObj = NULL;
- }
-}
+{}
PerlNodeFilterCallbackHandler::PerlNodeFilterCallbackHandler(SV *obj)
{
set_callback_obj(obj);
}
-// SV*
-// PerlNodeFilterCallbackHandler::set_callback_obj(SV* object) {
-// SV *oldRef = &PL_sv_undef; // default to 'undef'
-// if (callbackObj != NULL) {
-// oldRef = callbackObj;
-// #if defined(PERL_VERSION) && PERL_VERSION >= 8
-// // SvREFCNT_dec(oldRef);
-// #endif
-// }
-// SvREFCNT_inc(object);
-// callbackObj = object;
-// return oldRef;
-// }
-
short
PerlNodeFilterCallbackHandler::acceptNode (const DOMNode* node) const
{
@@ -56,6 +38,7 @@ PerlNodeFilterCallbackHandler::acceptNode (const DOMNode* node) const
return 0;
}
short accept = 0;
+ char *domNodeName = "XML::Xerces::DOMNode";
dSP;
@@ -66,8 +49,10 @@ PerlNodeFilterCallbackHandler::acceptNode (const DOMNode* node) const
// first put the callback object on the stack
XPUSHs(callbackObj);
- // the only argument is the node
- swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &node);
+ // the only argument is the node
+ // god bless John Lenz's new type system in SWIG 1.3.25!!!
+ swig_type_info *domNodeType = SWIG_TypeQuery(domNodeName);
+ swig_type_info *ty = SWIG_TypeDynamicCast(domNodeType, (void **) &node);
SV* node_sv = sv_newmortal();
SWIG_MakePtr(node_sv, (void *) node, ty,0);
XPUSHs(node_sv);
diff --git a/swig/perl/Makefile.PL b/swig/perl/Makefile.PL
index 8a00629a1..f7994496a 100644
--- a/swig/perl/Makefile.PL
+++ b/swig/perl/Makefile.PL
@@ -19,7 +19,11 @@ use Env qw(XERCES_CONFIG
XERCES_DEVEL
SWIG);
use strict;
-use vars qw($INCLUDES $CXX $CFLAGS @LDFLAGS @OPTIMIZE);
+use vars qw($INCLUDES $CXX $CFLAGS @LDFLAGS @OPTIMIZE $LIBS
+ $TRANSCODER_LIB $HANDLER_LIB
+ $XERCESCROOT $SWIG_DIR $PERL_DIR $HANDLER_DIR $SCRIPTS_DIR $INTERFACE_DIR
+ $SWIG_ARGS
+ );
use File::Basename;
use Cwd qw(abs_path);
@@ -48,7 +52,7 @@ upgrade to 5.7.2.
ERROR
}
-my $XERCESCROOT = abs_path('../..');
+$XERCESCROOT = abs_path('../..');
my $XERCES_INCLUDE = "$XERCESCROOT/src";
my $XERCES_LIB = "$XERCESCROOT/obj/.libs";
unless (-d $XERCES_LIB) {
@@ -57,9 +61,15 @@ unless (-d $XERCES_LIB) {
die "Error building Xerces-C\n$!"
if $?;
}
-my $LIBS = '-lpthread';
+$SWIG_DIR = "$XERCESCROOT/swig";
+$PERL_DIR = "$SWIG_DIR/perl";
+$HANDLER_DIR = "$PERL_DIR/Handler";
+$INTERFACE_DIR = "$SWIG_DIR/interfaces";
+$SCRIPTS_DIR = "$SWIG_DIR/scripts";
-$INCLUDES = '-I. -IHandler';
+$LIBS = '-lpthread';
+
+$INCLUDES = "-I$PERL_DIR -I$PERL_DIR/Handler -I$PERL_DIR/Transcoder";
print STDERR "Using XERCES_LIB = $XERCES_LIB\n";
$LIBS .= " -L$XERCES_LIB ";
@@ -198,13 +208,17 @@ EOE
print STDERR "Successfully located $libxerces_name!!\n";
-my $HANDLER_LIB = '$(INST_ARCHLIB)/auto/Handler/Handler$(LIB_EXT)';
+$HANDLER_LIB = '$(INST_ARCHLIB)/auto/Handler/Handler$(LIB_EXT)';
+$TRANSCODER_LIB = '$(INST_ARCHLIB)/auto/Transcoder/Transcoder$(LIB_EXT)';
sub MY_postamble {
qq[
$HANDLER_LIB:
\$(MAKE) -C Handler static
+
+$TRANSCODER_LIB:
+ \$(MAKE) -C Transcoder static
];
}
@@ -213,9 +227,6 @@ $HANDLER_LIB:
my @MACRO;
$CFLAGS .= '-D_REENTRANT';
-my $HANDLER_DIR = 'Handler';
-my $INTERFACE_DIR = '../interfaces';
-my $SCRIPTS_DIR = '../scripts';
# we only consider using SWIG if we are a Xerces Developer
if ($XERCES_DEVEL) {
# replace this with the path to your Unix compatible find application
@@ -230,43 +241,31 @@ if ($XERCES_DEVEL) {
chomp(@handler_headers = `$FIND $HANDLER_DIR -name "*.swig.hpp"`);
@OPTIMIZE = (OPTIMIZE => '-g');
+ $SWIG_ARGS = qq[-Wall -DXERCES_VERSION="$XERCES_PERL_VERSION" \$(INC) -perl5 -c++ -shadow];
+
sub Xerces_postamble {
chomp(my @import_files = `$FIND $HANDLER_DIR -name "*.i"`);
push(@header_files,@handler_headers,@import_files);
chomp(my @interface_files = `$FIND $INTERFACE_DIR -name "*.i"`);
- @interface_files = grep {$_ !~ /shadow\.i/} @interface_files;
- @dom_interface_files = grep {$_ =~ /dom/} @interface_files;
- @non_dom_interface_files = grep {$_ !~ /dom/} @interface_files;
+ @interface_files = grep {$_ !~ /shadow/} @interface_files;
+ @dom_interface_files = grep {$_ =~ /dom/i} @interface_files;
+ @non_dom_interface_files = grep {$_ !~ /dom/i} @interface_files;
local $" = ' ';
- my $OS_DEF;
- my $CC_DEF;
- if ($^O eq 'linux') {
- $OS_DEF = '-DXML_LINUX';
- } elsif($^O eq 'darwin') {
- $OS_DEF = '-DXML_MACOSX';
- } else {
- die 'unsupported operating system';
- }
- if ($CXX =~ /g\+\+/) {
- $CC_DEF = '-DXML_GCC';
- } else {
- die 'unsupported compiler';
- }
- my $SWIG_ARGS = qq[-Wall $OS_DEF $CC_DEF -DXERCES_VERSION="$XERCES_PERL_VERSION" \$(INC) -perl5 -c++ -shadow];
- my $MAKE = ' \$(MAKE) -C Handler static';
+ my $MAKE_HANDLER = ' \$(MAKE) -C Handler static';
+ my $MAKE_TRANSCODER = ' \$(MAKE) -C Transcoder static';
if ($^O eq 'MSWin32') {
# nmake doesn't not honor '-C'
- $MAKE = ' cd Handler && \$(MAKE) static';
+ $MAKE_HANDLER = ' cd Handler && \$(MAKE) static';
+ $MAKE_TRANSCODER = ' cd Transcoder && \$(MAKE) static';
}
### We no longer need to munge the C++ code thanks to SWIG improvements
# perl postSource.pl Xerces.cpp
my $retval = <<TERMINUS;
Xerces-tmp.pm: $SCRIPTS_DIR/postModule.pl $INTERFACE_DIR/Perl/shadow.i
- \$(SWIG) $SWIG_ARGS -o Xerces-tmp.cpp $INTERFACE_DIR/Xerces.i
- mv Xerces.pm Xerces-tmp.pm
+ \$(SWIG) $SWIG_ARGS -o Xerces-tmp.cpp -pm Xerces-tmp.pm $INTERFACE_DIR/Xerces.i
Xerces.pm: $SCRIPTS_DIR/postModule.pl Xerces-tmp.pm
perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postModule.pl --in=Xerces-tmp.pm --out=Xerces.pm
@@ -274,19 +273,22 @@ Xerces.pm: $SCRIPTS_DIR/postModule.pl Xerces-tmp.pm
Xerces.cpp: $SCRIPTS_DIR/postSource.pl Xerces-tmp.cpp
perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postSource.pl --in=Xerces-tmp.cpp --out=Xerces.cpp
-Xerces-tmp.cpp: $INTERFACE_DIR/Xerces.i @interface_files @header_files $INTERFACE_DIR/Perl/Xerces-extra.pm
- \$(SWIG) $SWIG_ARGS -o Xerces-tmp.cpp $INTERFACE_DIR/Xerces.i
- mv Xerces.pm Xerces-tmp.pm
+Xerces-tmp.cpp: $INTERFACE_DIR/Xerces.i @non_dom_interface_files @header_files $INTERFACE_DIR/Perl/Xerces-extra.pm
+ \$(SWIG) $SWIG_ARGS -o Xerces-tmp.cpp -pm Xerces-tmp.pm $INTERFACE_DIR/Xerces.i
perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postModule.pl --in=Xerces-tmp.pm --out=Xerces.pm
cp -f Xerces.pm blib/lib/XML/Xerces.pm
$HANDLER_LIB:
-$MAKE
+$MAKE_HANDLER
+
+$TRANSCODER_LIB:
+$MAKE_TRANSCODER
TERMINUS
return $retval;
}
print STDERR "Welcome Xerces Developer!\n";
+
# if we're to use SWIG, we need to know which version is available
my $swig = $SWIG || 'swig';
@MACRO = ('macro' => {
@@ -306,15 +308,17 @@ my $OBJS = 'Xerces$(OBJ_EXT)';
# see the hints/ directory for architecture specific stuff!
WriteMakefile(
'NAME' => 'XML::Xerces',
- 'AUTHOR' => 'The Xerces-P developers: p-dev@xerces.apache.org',
- 'ABSTRACT' => 'Perl Interface for Xerces XML API',
+ 'AUTHOR' => q[The Xerces-P developers: p-dev 'at' xerces 'dot' apache 'dot' org],
+ 'ABSTRACT' => 'Perl Interface for Apache Xerces XML API',
'CC' => $CXX,
'CCFLAGS' => $CFLAGS,
'PM' => {
'Xerces.pm' => '$(INST_LIB)/XML/Xerces.pm',
+ # 'DOM.pm' => '$(INST_LIB)/XML/Xerces/DOM.pm',
},
'INC' => $INCLUDES,
- 'MYEXTLIB' => $HANDLER_LIB,
+ 'MYEXTLIB' => "$HANDLER_LIB $TRANSCODER_LIB",
+# 'SKIP' => [qw( pm_to_blib )],
'LIBS' => [$LIBS],
'OBJECT' => $OBJS,
'VERSION' => "$XERCES_PERL_VERSION",
diff --git a/swig/perl/TODO b/swig/perl/TODO
index 6aa072dda..28060bd84 100644
--- a/swig/perl/TODO
+++ b/swig/perl/TODO
@@ -23,6 +23,14 @@ Samples:
Internals:
==========
+Sat Sep 9 2006
+* move other code out of XML::Xerces into new modules:
+ - Handler
+ - SAX
+ - SAX2
+* why are is createXMLReader dispatcher not working - mail swig-dev
+* why are we wrapping DefaultHandler??
+
Tue Aug 22 23:47:05 IST 2006
* need tests for the new DOM additions:
%include "dom/DOMLSException.i"
@@ -41,7 +49,6 @@ Tue Aug 22 23:47:05 IST 2006
%include "xercesc/dom/DOMXPathNSResolver.hpp"
%include "xercesc/dom/DOMXPathResult.hpp"
%include "xercesc/dom/DOMUserDataHandler.hpp"
-%include "xercesc/dom/DOMConfiguration.hpp"
%include "xercesc/dom/DOMStringList.hpp"
%include "xercesc/dom/DOMImplementationList.hpp"
%include "xercesc/dom/DOMImplementationSource.hpp"
@@ -49,7 +56,6 @@ Tue Aug 22 23:47:05 IST 2006
%include "xercesc/dom/DOMError.hpp"
Fri May 13 18:21:45 IST 2005
-* change the string typecheck to only do an SvOK()
* does Xerces have any methods were a NULL XMLCh* value is needed? -
if so we have to enable a %typemap to support it
* Xerces has some methods were a NULL pointer value is needed and some
@@ -68,7 +74,6 @@ Fri Jun 7 00:37:01 MDT 2002
Sun Jun 2 11:38:11 MDT 2002
* use %newobject and %typemape(newfree) for methods like removeNode()
-* look into using SWIG_RegisterMapping() instead of inheritance hack
### *** emacs file mode definition ***
### Local Variables:
diff --git a/swig/perl/Transcoder/Makefile.PL b/swig/perl/Transcoder/Makefile.PL
new file mode 100644
index 000000000..f4cab7cc1
--- /dev/null
+++ b/swig/perl/Transcoder/Makefile.PL
@@ -0,0 +1,49 @@
+ #
+ # Copyright 2002,2004 The Apache Software Foundation.
+ #
+ # Licensed under the Apache License, Version 2.0 (the "License");
+ # you may not use this file except in compliance with the License.
+ # You may obtain a copy of the License at
+ #
+ # http://www.apache.org/licenses/LICENSE-2.0
+ #
+ # Unless required by applicable law or agreed to in writing, software
+ # distributed under the License is distributed on an "AS IS" BASIS,
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ # See the License for the specific language governing permissions and
+ # limitations under the License.
+ #
+
+WriteMakefile(
+ LINKTYPE => 'static',
+ 'NAME' => 'Transcoder',
+ 'INC' => $INCLUDES,
+ 'OBJECT' => '$(O_FILES)',
+# 'CCFLAGS' => $CFLAGS,
+ 'CC' => $CXX,
+ 'SKIP' => [qw( dynamic test makeaperl xs_o)],
+ @OPTIMIZE,
+ @LDFLAGS,
+);
+
+__END__
+sub MY::static
+{
+ '
+static :: libtranscode$(LIB_EXT)
+
+dynamic :: static
+
+libtranscode$(LIB_EXT): $(O_FILES) $(MYEXTLIB)
+ $(AR) cru libtranscode$(LIB_EXT) $(O_FILES)
+ $(RANLIB) libtranscode$(LIB_EXT)
+
+libtranscode.$(DLEXT): $(LDFROM) $(MYEXTLIB)
+ $(LD) -o libtranscode.$(DLEXT) $(LDDLFLAGS) --whole-archive $(LDFROM) $(OTHERLDFLAGS) $(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) $(EXPORT_LIST)
+ $(CHMOD) 755 libtranscode.$(DLEXT)
+
+';
+
+}
+
+
diff --git a/swig/perl/Transcoder/Transcoder.cpp b/swig/perl/Transcoder/Transcoder.cpp
new file mode 100644
index 000000000..1e8c5366a
--- /dev/null
+++ b/swig/perl/Transcoder/Transcoder.cpp
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include "Transcoder.hpp"
+
+Transcoder* Transcoder::_instance = NULL;
+
+Transcoder*
+Transcoder::getInstance() {
+ // fprintf(stderr, "getInstance: finding instance\n");
+ if (_instance == NULL) {
+ // fprintf(stderr, "getInstance: making new transcoder\n");
+ _instance = new Transcoder();
+ }
+ return _instance;
+}
+
+Transcoder::~Transcoder() {
+ // fprintf(stderr, "Deleting transcoder\n");
+}
+
+Transcoder::Transcoder() {
+ XMLTransService::Codes failReason;
+
+ // we assume that the Xerces-C transcoding service is already initialized
+ // via XMLPlatformUtils::Initialize()
+ UTF8_TRANSCODER = XMLPlatformUtils::fgTransService->makeNewTranscoderFor(
+ XMLUni::fgUTF8EncodingString,
+ failReason,
+ 1024);
+
+ if (UTF8_TRANSCODER == NULL) {
+ croak("ERROR: Transcoder Could not create UTF-8 transcoder");
+ } else if (failReason == XMLTransService::UnsupportedEncoding) {
+ croak("ERROR: Transcoder: unsupported encoding");
+ } else if (failReason == XMLTransService::InternalFailure) {
+ croak("ERROR: Transcoder: internal failure");
+ } else if (failReason == XMLTransService::SupportFilesNotFound) {
+ croak("ERROR: Transcoder: support files not found");
+ } else if (failReason == XMLTransService::Ok) {
+ // fprintf(stderr, "Created transcoder ok\n");
+ }
+}
+
+SV*
+Transcoder::XMLString2Perl(const XMLCh* input) {
+ SV *output;
+ unsigned int charsEaten = 0;
+ int length = XMLString::stringLen(input); // string length
+ // use +1 to make room for the '\0' at the end of the string
+ // in the pathological case when each character of the string
+ // is UTF8_MAXLEN bytes long
+ XMLByte* res = new XMLByte[(length * UTF8_MAXLEN) + 1]; // output string
+
+ unsigned int total_chars =
+ UTF8_TRANSCODER->transcodeTo((const XMLCh*) input,
+ (unsigned int) length,
+ (XMLByte*) res,
+ (unsigned int) (length*UTF8_MAXLEN),
+ charsEaten,
+ XMLTranscoder::UnRep_Throw
+ );
+ res[total_chars] = '\0';
+
+#if (0)
+ if (DEBUG_UTF8_OUT) {
+ printf("Xerces out length = %d: ",total_chars);
+ for (int i=0;i<length;i++){
+ printf("<0x%.4X>",res[i]);
+ }
+ printf("\n");
+ }
+#endif
+
+ output = sv_newmortal();
+ sv_setpv((SV*)output, (char *)res );
+ SvUTF8_on((SV*)output);
+ delete[] res;
+ return output;
+}
+
+XMLCh*
+Transcoder::Perl2XMLString(SV* input){
+ XMLCh* output;
+
+ STRLEN length;
+ char *ptr = (char *)SvPVutf8(input,length);
+
+#if (0)
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+#endif
+
+ if (SvUTF8(input)) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ output = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) output,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+
+#if (0)
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",output[i]);
+ }
+ printf("\n");
+ }
+#endif
+
+ // indicate the end of the string
+ output[chars_stored] = '\0';
+ } else {
+ output = XMLString::transcode(ptr);
+
+#if (0)
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;output[i];i++){
+ printf("<0x%.4X>",output[i]);
+ }
+ printf("\n");
+ }
+#endif
+
+ }
+ return(output);
+}
diff --git a/swig/perl/Transcoder/Transcoder.hpp b/swig/perl/Transcoder/Transcoder.hpp
new file mode 100644
index 000000000..eba04e560
--- /dev/null
+++ b/swig/perl/Transcoder/Transcoder.hpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TRANSCODER
+#define __TRANSCODER
+
+/* Needed on some windows machines---since MS plays funny
+ games with the header files under C++ */
+extern "C" {
+
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+/* Get rid of free and malloc defined by perl */
+#undef free
+#undef malloc
+
+}
+
+
+#include "xercesc/util/TransService.hpp"
+#include "xercesc/util/PlatformUtils.hpp"
+
+XERCES_CPP_NAMESPACE_USE
+
+class Transcoder {
+
+private:
+ static Transcoder* _instance;
+
+protected:
+
+ Transcoder();
+ XMLTranscoder* UTF8_TRANSCODER;
+
+public:
+
+ static Transcoder* getInstance();
+
+ ~Transcoder();
+
+ SV* XMLString2Perl(const XMLCh*);
+ XMLCh* Perl2XMLString(SV*);
+};
+
+#endif /* __TRANSCODER */
diff --git a/swig/perl/Transcoder/XMLExceptionHandler.cpp b/swig/perl/Transcoder/XMLExceptionHandler.cpp
new file mode 100644
index 000000000..e88612d55
--- /dev/null
+++ b/swig/perl/Transcoder/XMLExceptionHandler.cpp
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include "XMLExceptionHandler.hpp"
+
+XMLExceptionHandler* XMLExceptionHandler::_instance = NULL;
+
+XMLExceptionHandler*
+XMLExceptionHandler::getInstance() {
+ if (_instance == NULL) {
+ _instance = new XMLExceptionHandler();
+ }
+ return _instance;
+}
+
+XMLExceptionHandler::XMLExceptionHandler() {}
+
+XMLException*
+XMLExceptionHandler::copyXMLException(const XMLException& e)
+{
+ if(e.getType() == XMLUni::fgArrayIndexOutOfBoundsException_Name)
+ {
+ return (XMLException*)((ArrayIndexOutOfBoundsException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgEmptyStackException_Name)
+ {
+ return (XMLException*)((EmptyStackException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgIllegalArgumentException_Name)
+ {
+ return (XMLException*)((IllegalArgumentException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgInvalidCastException_Name)
+ {
+ return (XMLException*)((InvalidCastException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgIOException_Name)
+ {
+ return (XMLException*)((IOException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgNoSuchElementException_Name)
+ {
+ return (XMLException*)((NoSuchElementException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgNullPointerException_Name)
+ {
+ return (XMLException*)((NullPointerException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgNumberFormatException_Name)
+ {
+ return (XMLException*)((NumberFormatException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgParseException_Name)
+ {
+ return (XMLException*)((ParseException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgXMLPlatformUtilsException_Name)
+ {
+ return (XMLException*)((XMLPlatformUtilsException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgRuntimeException_Name)
+ {
+ return (XMLException*)((RuntimeException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgSchemaDateTimeException_Name)
+ {
+ return (XMLException*)((SchemaDateTimeException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgTranscodingException_Name)
+ {
+ return (XMLException*)((TranscodingException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgUnexpectedEOFException_Name)
+ {
+ return (XMLException*)((UnexpectedEOFException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgUnsupportedEncodingException_Name)
+ {
+ return (XMLException*)((UnsupportedEncodingException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgUTFDataFormatException_Name)
+ {
+ return (XMLException*)((UTFDataFormatException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgNetAccessorException_Name)
+ {
+ return (XMLException*)((NetAccessorException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgMalformedURLException_Name)
+ {
+ return (XMLException*)((MalformedURLException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgXSerializationException_Name)
+ {
+ return (XMLException*)((XSerializationException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgInvalidDatatypeFacetException_Name)
+ {
+ return (XMLException*)((InvalidDatatypeFacetException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgInvalidDatatypeValueException_Name)
+ {
+ return (XMLException*)((InvalidDatatypeValueException*)&e)->duplicate();
+ }
+ else if(e.getType() == XMLUni::fgXPathException_Name)
+ {
+ return (XMLException*)((XPathException*)&e)->duplicate();
+ }
+ else
+ {
+ croak("Unknown Exception type: %d", e.getType());
+ }
+}
diff --git a/swig/perl/Transcoder/XMLExceptionHandler.hpp b/swig/perl/Transcoder/XMLExceptionHandler.hpp
new file mode 100644
index 000000000..f26cc25f9
--- /dev/null
+++ b/swig/perl/Transcoder/XMLExceptionHandler.hpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2002,2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __XMLEXCEPTIONHANDLER
+#define __XMLEXCEPTIONHANDLER
+
+/* Needed on some windows machines---since MS plays funny
+ games with the header files under C++ */
+extern "C" {
+
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+/* Get rid of free and malloc defined by perl */
+#undef free
+#undef malloc
+
+}
+
+#include "xercesc/util/ArrayIndexOutOfBoundsException.hpp"
+#include "xercesc/util/EmptyStackException.hpp"
+#include "xercesc/util/IllegalArgumentException.hpp"
+#include "xercesc/util/InvalidCastException.hpp"
+#include "xercesc/util/IOException.hpp"
+#include "xercesc/util/NoSuchElementException.hpp"
+#include "xercesc/util/NullPointerException.hpp"
+#include "xercesc/util/NumberFormatException.hpp"
+#include "xercesc/util/ParseException.hpp"
+#include "xercesc/util/RuntimeException.hpp"
+#include "xercesc/util/SchemaDateTimeException.hpp"
+#include "xercesc/util/TranscodingException.hpp"
+#include "xercesc/util/UnexpectedEOFException.hpp"
+#include "xercesc/util/UnsupportedEncodingException.hpp"
+#include "xercesc/util/UTFDataFormatException.hpp"
+#include "xercesc/util/XMLNetAccessor.hpp"
+#include "xercesc/internal/XSerializationException.hpp"
+#include "xercesc/validators/datatype/InvalidDatatypeFacetException.hpp"
+#include "xercesc/validators/datatype/InvalidDatatypeValueException.hpp"
+#include "xercesc/validators/schema/identity/XPathException.hpp"
+
+XERCES_CPP_NAMESPACE_USE
+
+class XMLExceptionHandler {
+
+protected:
+
+ XMLExceptionHandler();
+ static XMLExceptionHandler* _instance;
+
+public:
+
+ static XMLExceptionHandler* getInstance();
+
+ ~XMLExceptionHandler();
+ XMLException* copyXMLException(const XMLException& e);
+};
+
+#endif /* __XMLEXCEPTIONHANDLER */
diff --git a/swig/perl/Xerces.cpp b/swig/perl/Xerces.cpp
index 9396e66b6..48e62d8f5 100644
--- a/swig/perl/Xerces.cpp
+++ b/swig/perl/Xerces.cpp
@@ -1451,177 +1451,116 @@ SWIG_Perl_SetModule(swig_module_info *module) {
#define SWIGTYPE_p_PerlDocumentCallbackHandler swig_types[9]
#define SWIGTYPE_p_PerlEntityResolverHandler swig_types[10]
#define SWIGTYPE_p_PerlErrorCallbackHandler swig_types[11]
-#define SWIGTYPE_p_PerlNodeFilterCallbackHandler swig_types[12]
-#define SWIGTYPE_p_RefArrayVectorOfTuint16_t_t swig_types[13]
-#define SWIGTYPE_p_RefHash2KeysTableOfTValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t_t swig_types[14]
-#define SWIGTYPE_p_RefHashTableOfTXERCES_CPP_NAMESPACE__ComplexTypeInfo_t swig_types[15]
-#define SWIGTYPE_p_RefHashTableOfTXERCES_CPP_NAMESPACE__XMLAttDef_t swig_types[16]
-#define SWIGTYPE_p_RefHashTableOfTXERCES_CPP_NAMESPACE__XSAnnotation_t swig_types[17]
-#define SWIGTYPE_p_RefHashTableOfTXERCES_CPP_NAMESPACE__XercesAttGroupInfo_t swig_types[18]
-#define SWIGTYPE_p_RefHashTableOfTXERCES_CPP_NAMESPACE__XercesGroupInfo_t swig_types[19]
-#define SWIGTYPE_p_SecurityManager swig_types[20]
-#define SWIGTYPE_p_ValidationContext swig_types[21]
-#define SWIGTYPE_p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t swig_types[22]
-#define SWIGTYPE_p_ValueVectorOfTunsigned_int_t swig_types[23]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser swig_types[24]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList swig_types[25]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes swig_types[26]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__BinInputStream swig_types[27]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__ComplexTypeInfo swig_types[28]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler swig_types[29]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentSpecNode swig_types[30]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr swig_types[31]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection swig_types[32]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData swig_types[33]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment swig_types[34]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration swig_types[35]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument swig_types[36]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment swig_types[37]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentRange swig_types[38]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal swig_types[39]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType swig_types[40]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement swig_types[41]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity swig_types[42]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference swig_types[43]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError swig_types[44]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMErrorHandler swig_types[45]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException swig_types[46]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation swig_types[47]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS swig_types[48]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList swig_types[49]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry swig_types[50]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource swig_types[51]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException swig_types[52]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput swig_types[53]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput swig_types[54]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser swig_types[55]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParserFilter swig_types[56]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver swig_types[57]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer swig_types[58]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter swig_types[59]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator swig_types[60]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap swig_types[61]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode swig_types[62]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter swig_types[63]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator swig_types[64]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList swig_types[65]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation swig_types[66]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo swig_types[67]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction swig_types[68]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange swig_types[69]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException swig_types[70]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList swig_types[71]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText swig_types[72]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker swig_types[73]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo swig_types[74]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler swig_types[75]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator swig_types[76]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException swig_types[77]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathExpression swig_types[78]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver swig_types[79]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNamespace swig_types[80]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult swig_types[81]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDAttDef swig_types[82]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDAttDefList swig_types[83]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDElementDecl swig_types[84]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDEntityDecl swig_types[85]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDGrammar swig_types[86]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler swig_types[87]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDValidator swig_types[88]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DatatypeValidator swig_types[89]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler swig_types[90]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler swig_types[91]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler swig_types[92]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__EntityResolver swig_types[93]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler swig_types[94]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar swig_types[95]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__GrammarResolver swig_types[96]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase swig_types[97]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource swig_types[98]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler swig_types[99]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget swig_types[100]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileInputSource swig_types[101]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator swig_types[102]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget swig_types[103]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufInputSource swig_types[104]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager swig_types[105]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[106]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[107]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__XMLNotationDecl_t swig_types[108]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[109]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[110]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NamespaceScope swig_types[111]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler swig_types[112]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Parser swig_types[113]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__QName swig_types[114]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[115]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[116]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader swig_types[117]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException swig_types[118]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException swig_types[119]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException swig_types[120]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException swig_types[121]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser swig_types[122]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaAttDef swig_types[123]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaAttDefList swig_types[124]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaElementDecl swig_types[125]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaGrammar swig_types[126]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaValidator swig_types[127]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdInInputSource swig_types[128]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget swig_types[129]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource swig_types[130]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput swig_types[131]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource swig_types[132]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttDef swig_types[133]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttDefList swig_types[134]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLContentModel swig_types[135]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDTDDescription swig_types[136]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDeleter swig_types[137]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDocumentHandler swig_types[138]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLElementDecl swig_types[139]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityDecl swig_types[140]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityResolver swig_types[141]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[142]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[143]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[144]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLException swig_types[145]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLExcepts swig_types[146]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget swig_types[147]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter swig_types[148]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription swig_types[149]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool swig_types[150]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLNotationDecl swig_types[151]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken swig_types[152]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPlatformUtils swig_types[153]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLReaderFactory swig_types[154]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLSchemaDescription swig_types[155]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLURL swig_types[156]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLUni swig_types[157]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLUri swig_types[158]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator swig_types[159]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMemory swig_types[160]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XSAnnotation swig_types[161]
-#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser swig_types[162]
-#define SWIGTYPE_p_XMLAtomicOpMgr swig_types[163]
-#define SWIGTYPE_p_XMLBuffer swig_types[164]
-#define SWIGTYPE_p_XMLErrorReporter swig_types[165]
-#define SWIGTYPE_p_XMLErrorReporter__ErrTypes swig_types[166]
-#define SWIGTYPE_p_XMLFileMgr swig_types[167]
-#define SWIGTYPE_p_XMLMutexMgr swig_types[168]
-#define SWIGTYPE_p_XSerializeEngine swig_types[169]
-#define SWIGTYPE_p_bool swig_types[170]
-#define SWIGTYPE_p_char swig_types[171]
-#define SWIGTYPE_p_int swig_types[172]
-#define SWIGTYPE_p_int32_t swig_types[173]
-#define SWIGTYPE_p_p_void swig_types[174]
-#define SWIGTYPE_p_size_t swig_types[175]
-#define SWIGTYPE_p_ssize_t swig_types[176]
-#define SWIGTYPE_p_uint16_t swig_types[177]
-#define SWIGTYPE_p_uint32_t swig_types[178]
-#define SWIGTYPE_p_unsigned_char swig_types[179]
-#define SWIGTYPE_p_void swig_types[180]
-static swig_type_info *swig_types[182];
-static swig_module_info swig_module = {swig_types, 181, 0, 0, 0, 0};
+#define SWIGTYPE_p_RefArrayVectorOfTuint16_t_t swig_types[12]
+#define SWIGTYPE_p_RefHash2KeysTableOfTValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t_t swig_types[13]
+#define SWIGTYPE_p_RefHashTableOfTXERCES_CPP_NAMESPACE__ComplexTypeInfo_t swig_types[14]
+#define SWIGTYPE_p_RefHashTableOfTXERCES_CPP_NAMESPACE__XMLAttDef_t swig_types[15]
+#define SWIGTYPE_p_RefHashTableOfTXERCES_CPP_NAMESPACE__XSAnnotation_t swig_types[16]
+#define SWIGTYPE_p_RefHashTableOfTXERCES_CPP_NAMESPACE__XercesAttGroupInfo_t swig_types[17]
+#define SWIGTYPE_p_RefHashTableOfTXERCES_CPP_NAMESPACE__XercesGroupInfo_t swig_types[18]
+#define SWIGTYPE_p_SecurityManager swig_types[19]
+#define SWIGTYPE_p_ValidationContext swig_types[20]
+#define SWIGTYPE_p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t swig_types[21]
+#define SWIGTYPE_p_ValueVectorOfTunsigned_int_t swig_types[22]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList swig_types[23]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes swig_types[24]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__BinInputStream swig_types[25]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__ComplexTypeInfo swig_types[26]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler swig_types[27]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentSpecNode swig_types[28]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDAttDef swig_types[29]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDAttDefList swig_types[30]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDElementDecl swig_types[31]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDEntityDecl swig_types[32]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDGrammar swig_types[33]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler swig_types[34]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDValidator swig_types[35]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DatatypeValidator swig_types[36]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler swig_types[37]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler swig_types[38]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler swig_types[39]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__EntityResolver swig_types[40]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler swig_types[41]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar swig_types[42]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__GrammarResolver swig_types[43]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase swig_types[44]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource swig_types[45]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler swig_types[46]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileInputSource swig_types[47]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator swig_types[48]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufInputSource swig_types[49]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager swig_types[50]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[51]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[52]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__XMLNotationDecl_t swig_types[53]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[54]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[55]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NamespaceScope swig_types[56]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler swig_types[57]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Parser swig_types[58]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__QName swig_types[59]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[60]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[61]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader swig_types[62]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException swig_types[63]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException swig_types[64]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException swig_types[65]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException swig_types[66]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser swig_types[67]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaAttDef swig_types[68]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaAttDefList swig_types[69]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaElementDecl swig_types[70]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaGrammar swig_types[71]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaValidator swig_types[72]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdInInputSource swig_types[73]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource swig_types[74]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttDef swig_types[75]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttDefList swig_types[76]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLContentModel swig_types[77]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDTDDescription swig_types[78]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDeleter swig_types[79]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDocumentHandler swig_types[80]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLElementDecl swig_types[81]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityDecl swig_types[82]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityResolver swig_types[83]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[84]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[85]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[86]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLException swig_types[87]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLExcepts swig_types[88]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription swig_types[89]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool swig_types[90]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLNotationDecl swig_types[91]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken swig_types[92]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPlatformUtils swig_types[93]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLReaderFactory swig_types[94]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLSchemaDescription swig_types[95]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLURL swig_types[96]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLUni swig_types[97]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLUri swig_types[98]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator swig_types[99]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMemory swig_types[100]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XSAnnotation swig_types[101]
+#define SWIGTYPE_p_XMLAtomicOpMgr swig_types[102]
+#define SWIGTYPE_p_XMLBuffer swig_types[103]
+#define SWIGTYPE_p_XMLErrorReporter swig_types[104]
+#define SWIGTYPE_p_XMLErrorReporter__ErrTypes swig_types[105]
+#define SWIGTYPE_p_XMLFileMgr swig_types[106]
+#define SWIGTYPE_p_XMLMutexMgr swig_types[107]
+#define SWIGTYPE_p_XSerializeEngine swig_types[108]
+#define SWIGTYPE_p_bool swig_types[109]
+#define SWIGTYPE_p_char swig_types[110]
+#define SWIGTYPE_p_int swig_types[111]
+#define SWIGTYPE_p_int32_t swig_types[112]
+#define SWIGTYPE_p_p_void swig_types[113]
+#define SWIGTYPE_p_size_t swig_types[114]
+#define SWIGTYPE_p_ssize_t swig_types[115]
+#define SWIGTYPE_p_uint16_t swig_types[116]
+#define SWIGTYPE_p_uint32_t swig_types[117]
+#define SWIGTYPE_p_unsigned_char swig_types[118]
+#define SWIGTYPE_p_void swig_types[119]
+static swig_type_info *swig_types[121];
+static swig_module_info swig_module = {swig_types, 120, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
@@ -1701,61 +1640,9 @@ SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
#include "xercesc/framework/StdOutFormatTarget.hpp"
#include "xercesc/framework/psvi/PSVIHandler.hpp"
-// for resolving XMLExceptions
-#include "xercesc/util/ArrayIndexOutOfBoundsException.hpp"
-#include "xercesc/util/EmptyStackException.hpp"
-#include "xercesc/util/IllegalArgumentException.hpp"
-#include "xercesc/util/InvalidCastException.hpp"
-#include "xercesc/util/IOException.hpp"
-#include "xercesc/util/NoSuchElementException.hpp"
-#include "xercesc/util/NullPointerException.hpp"
-#include "xercesc/util/NumberFormatException.hpp"
-#include "xercesc/util/ParseException.hpp"
-#include "xercesc/util/RuntimeException.hpp"
-#include "xercesc/util/SchemaDateTimeException.hpp"
-#include "xercesc/util/TranscodingException.hpp"
-#include "xercesc/util/UnexpectedEOFException.hpp"
-#include "xercesc/util/UnsupportedEncodingException.hpp"
-#include "xercesc/util/UTFDataFormatException.hpp"
-#include "xercesc/util/XMLNetAccessor.hpp"
-#include "xercesc/internal/XSerializationException.hpp"
-#include "xercesc/validators/datatype/InvalidDatatypeFacetException.hpp"
-#include "xercesc/validators/datatype/InvalidDatatypeValueException.hpp"
-#include "xercesc/validators/schema/identity/XPathException.hpp"
-
-//
-// DOM stuff - wants to be moved to seperate module
-//
-#include "xercesc/dom/DOM.hpp"
-#include "xercesc/framework/Wrapper4InputSource.hpp"
-#include "xercesc/framework/Wrapper4DOMLSInput.hpp"
-#include "xercesc/parsers/AbstractDOMParser.hpp"
-#include "xercesc/parsers/XercesDOMParser.hpp"
-
-// need this for PerlNodeFilterCallbackHandler
-// #include "xercesc/dom/DOMNode.hpp"
-XERCES_CPP_NAMESPACE_USE
-
-// we initialize the static UTF-8 transcoding info
-// these are used by the typemaps to convert between
-// Xerces internal UTF-16 and Perl's internal UTF-8
-static XMLCh* UTF8_ENCODING = NULL;
-static XMLTranscoder* UTF8_TRANSCODER = NULL;
-
-static bool DEBUG_UTF8_OUT = 0;
-static bool DEBUG_UTF8_IN = 0;
-
-
-#include "PerlCallbackHandler.hpp"
-#include "PerlErrorCallbackHandler.hpp"
-#include "PerlDocumentCallbackHandler.hpp"
-#include "PerlContentCallbackHandler.hpp"
-#include "PerlEntityResolverHandler.i"
-#include "PerlNodeFilterCallbackHandler.i"
-
static void
SWIG_Disown(SV *sv) {
@@ -1848,104 +1735,7 @@ SWIG_Disown(SV *sv) {
-SV*
-XMLString2Perl(const XMLCh* input) {
- SV *output;
- unsigned int charsEaten = 0;
- int length = XMLString::stringLen(input); // string length
- // use +1 to make room for the '\0' at the end of the string
- // in the pathological case when each character of the string
- // is UTF8_MAXLEN bytes long
- XMLByte* res = new XMLByte[(length * UTF8_MAXLEN) + 1]; // output string
-
- unsigned int total_chars =
- UTF8_TRANSCODER->transcodeTo((const XMLCh*) input,
- (unsigned int) length,
- (XMLByte*) res,
- (unsigned int) (length*UTF8_MAXLEN),
- charsEaten,
- XMLTranscoder::UnRep_Throw
- );
- res[total_chars] = '\0';
-
-#if (0)
- if (DEBUG_UTF8_OUT) {
- printf("Xerces out length = %d: ",total_chars);
- for (int i=0;i<length;i++){
- printf("<0x%.4X>",res[i]);
- }
- printf("\n");
- }
-#endif
-
- output = sv_newmortal();
- sv_setpv((SV*)output, (char *)res );
- SvUTF8_on((SV*)output);
- delete[] res;
- return output;
-}
-
-XMLCh*
-Perl2XMLString(SV* input){
- XMLCh* output;
-
- STRLEN length;
- char *ptr = (char *)SvPVutf8(input,length);
-
-#if (0)
- if (DEBUG_UTF8_IN) {
- printf("Perl in length = %d: ",length);
- for (unsigned int i=0;i<length;i++){
- printf("<0x%.4X>",ptr[i]);
- }
- printf("\n");
- }
-#endif
-
- if (SvUTF8(input)) {
- unsigned int charsEaten = 0;
- unsigned char* sizes = new unsigned char[length+1];
- output = new XMLCh[length+1];
- unsigned int chars_stored =
- UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
- (unsigned int) length,
- (XMLCh*) output,
- (unsigned int) length,
- charsEaten,
- (unsigned char*)sizes
- );
- delete [] sizes;
-
-#if (0)
- if (DEBUG_UTF8_IN) {
- printf("Xerces in length = %d: ",chars_stored);
- for (unsigned int i=0;i<chars_stored;i++){
- printf("<0x%.4X>",output[i]);
- }
- printf("\n");
- }
-#endif
-
- // indicate the end of the string
- output[chars_stored] = '\0';
- } else {
- output = XMLString::transcode(ptr);
-
-#if (0)
- if (DEBUG_UTF8_IN) {
- printf("Xerces: ");
- for (int i=0;output[i];i++){
- printf("<0x%.4X>",output[i]);
- }
- printf("\n");
- }
-#endif
-
- }
- return(output);
-}
-
-
+#define SWIG_SetErrorf SWIG_Perl_SetErrorf
static void
SWIG_Perl_SetErrorf(const char *fmt, ...) {
@@ -1986,6 +1776,33 @@ SWIG_Perl_TypeError(const char *type, int argnum, const char *symname)
}
+
+#include "Transcoder.hpp"
+#include "XMLExceptionHandler.hpp"
+
+#include "PerlCallbackHandler.hpp"
+#include "PerlErrorCallbackHandler.hpp"
+#include "PerlDocumentCallbackHandler.hpp"
+#include "PerlContentCallbackHandler.hpp"
+#include "PerlEntityResolverHandler.hpp"
+
+
+
+
+XERCES_CPP_NAMESPACE_USE
+
+// we initialize the static UTF-8 transcoding info
+// these are used by the typemaps to convert between
+// Xerces internal UTF-16 and Perl's internal UTF-8
+static Transcoder* UTF8_TRANSCODER = NULL;
+
+static XMLExceptionHandler* XML_EXCEPTION_HANDLER = NULL;
+
+static bool DEBUG_UTF8_OUT = 0;
+static bool DEBUG_UTF8_IN = 0;
+
+
+
SWIGINTERN int
SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
{
@@ -2081,107 +1898,11 @@ SWIG_From_bool SWIG_PERL_DECL_ARGS_1(bool value)
}
-XMLException*
-copyXMLException(const XMLException& e)
-{
- if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgArrayIndexOutOfBoundsException_Name)
- {
- return (XMLException*)((ArrayIndexOutOfBoundsException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgEmptyStackException_Name)
- {
- return (XMLException*)((EmptyStackException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgIllegalArgumentException_Name)
- {
- return (XMLException*)((IllegalArgumentException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgInvalidCastException_Name)
- {
- return (XMLException*)((InvalidCastException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgIOException_Name)
- {
- return (XMLException*)((IOException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgNoSuchElementException_Name)
- {
- return (XMLException*)((NoSuchElementException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgNullPointerException_Name)
- {
- return (XMLException*)((NullPointerException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgNumberFormatException_Name)
- {
- return (XMLException*)((NumberFormatException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgParseException_Name)
- {
- return (XMLException*)((ParseException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgXMLPlatformUtilsException_Name)
- {
- return (XMLException*)((XMLPlatformUtilsException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgRuntimeException_Name)
- {
- return (XMLException*)((RuntimeException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgSchemaDateTimeException_Name)
- {
- return (XMLException*)((SchemaDateTimeException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgTranscodingException_Name)
- {
- return (XMLException*)((TranscodingException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgUnexpectedEOFException_Name)
- {
- return (XMLException*)((UnexpectedEOFException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgUnsupportedEncodingException_Name)
- {
- return (XMLException*)((UnsupportedEncodingException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgUTFDataFormatException_Name)
- {
- return (XMLException*)((UTFDataFormatException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgNetAccessorException_Name)
- {
- return (XMLException*)((NetAccessorException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgMalformedURLException_Name)
- {
- return (XMLException*)((MalformedURLException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgXSerializationException_Name)
- {
- return (XMLException*)((XSerializationException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgInvalidDatatypeFacetException_Name)
- {
- return (XMLException*)((InvalidDatatypeFacetException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgInvalidDatatypeValueException_Name)
- {
- return (XMLException*)((InvalidDatatypeValueException*)&e)->duplicate();
- }
- else if(e.getType() == XERCES_CPP_NAMESPACE::XMLUni::fgXPathException_Name)
- {
- return (XMLException*)((XPathException*)&e)->duplicate();
- }
- else
- {
- SWIG_Perl_SetErrorf("Unknown Exception type: %d", e.getType());
- }
-}
void
makeXMLException(const XMLException& e){
SV *error = ERRSV;
- SWIG_MakePtr(error, (void *) copyXMLException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLException, SWIG_SHADOW|0);
+ SWIG_MakePtr(error, (void *) XML_EXCEPTION_HANDLER->copyXMLException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLException, SWIG_SHADOW|0);
}
void
@@ -2196,12 +1917,6 @@ makeSAXNotSupportedException(const SAXNotSupportedException& e){
SWIG_MakePtr(error, (void *) new SAXNotSupportedException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, SWIG_SHADOW|0);
}
-void
-makeDOMException(const DOMException& e){
- SV *error = ERRSV;
- SWIG_MakePtr(error, (void *) new DOMException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_SHADOW|0);
-}
-
static swig_type_info *
@@ -2221,53 +1936,6 @@ Grammar_dynamic_cast(void **ptr) {
}
-static swig_type_info *
-DOMNode_dynamic_cast(void **ptr) {
- DOMNode **nptr = (DOMNode **) ptr;
- if (*nptr == NULL) {
- return NULL;
- }
- short int type = (*nptr)->getNodeType();
- if (type == DOMNode::TEXT_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText;
- }
- if (type == DOMNode::PROCESSING_INSTRUCTION_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction;
- }
- if (type == DOMNode::DOCUMENT_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument;
- }
- if (type == DOMNode::ELEMENT_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement;
- }
- if (type == DOMNode::ENTITY_REFERENCE_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference;
- }
- if (type == DOMNode::CDATA_SECTION_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection;
- }
- if (type == DOMNode::CDATA_SECTION_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection;
- }
- if (type == DOMNode::COMMENT_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment;
- }
- if (type == DOMNode::DOCUMENT_TYPE_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType;
- }
- if (type == DOMNode::ENTITY_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity;
- }
- if (type == DOMNode::ATTRIBUTE_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr;
- }
- if (type == DOMNode::NOTATION_NODE) {
- return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation;
- }
- return NULL;
-}
-
-
#define CATCH_XML_EXCEPTION \
catch (const XMLException& e) \
{ \
@@ -2514,53 +2182,6 @@ SWIG_AsVal_unsigned_SS_int SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned int *val)
}
-#define CATCH_DOM_EXCEPTION \
- catch (const XMLException& e) \
- { \
- makeXMLException(e); \
- goto fail; \
- } \
- catch (const DOMException& e) \
- { \
- makeDOMException(e); \
- goto fail; \
- } \
- catch (...) \
- { \
- SWIG_croak("Handling Unknown exception"); \
- goto fail; \
- }
-
-
-SWIGINTERN int
-SWIG_AsVal_short SWIG_PERL_DECL_ARGS_2(SV * obj, short *val)
-{
- long v;
- int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
- if (SWIG_IsOK(res)) {
- if ((v < SHRT_MIN || v > SHRT_MAX)) {
- return SWIG_OverflowError;
- } else {
- if (val) *val = static_cast< short >(v);
- }
- }
- return res;
-}
-
-
-SWIGINTERNINLINE SV *
-SWIG_From_short SWIG_PERL_DECL_ARGS_1(short value)
-{
- return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
-}
-
-SWIGINTERN bool XERCES_CPP_NAMESPACE_DOMNode_operator_Se__Se_(XERCES_CPP_NAMESPACE::DOMNode *self,XERCES_CPP_NAMESPACE::DOMNode const *other){
- return self->isSameNode(other);
- }
-SWIGINTERN bool XERCES_CPP_NAMESPACE_DOMNode_operator_SN__Se_(XERCES_CPP_NAMESPACE::DOMNode *self,XERCES_CPP_NAMESPACE::DOMNode const *other){
- return !self->isSameNode(other);
- }
-
SWIGINTERNINLINE SV *
SWIG_From_size_t SWIG_PERL_DECL_ARGS_1(size_t value)
{
@@ -2579,30 +2200,21 @@ SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
SWIGINTERN int
-SWIG_AsVal_unsigned_SS_short SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned short *val)
+SWIG_AsVal_short SWIG_PERL_DECL_ARGS_2(SV * obj, short *val)
{
- unsigned long v;
- int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
+ long v;
+ int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
if (SWIG_IsOK(res)) {
- if ((v > USHRT_MAX)) {
+ if ((v < SHRT_MIN || v > SHRT_MAX)) {
return SWIG_OverflowError;
} else {
- if (val) *val = static_cast< unsigned short >(v);
+ if (val) *val = static_cast< short >(v);
}
}
return res;
}
-SWIGINTERNINLINE SV *
-SWIG_From_double SWIG_PERL_DECL_ARGS_1(double value)
-{
- SV *obj = sv_newmortal();
- sv_setnv(obj, value);
- return obj;
-}
-
-
#define CATCH_SAX_EXCEPTION \
catch (const XMLException& e) \
{ \
@@ -2772,7 +2384,7 @@ SWIGCLASS_STATIC int _wrap_XMLPlatformUtils_fgXMLChBigEndian_get(pTHX_ SV *sv, M
SWIGCLASS_STATIC int _wrap_XMLUni_fgAnyString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgAnyString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgAnyString));
return 1;
}
@@ -2781,7 +2393,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgAnyString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSE
SWIGCLASS_STATIC int _wrap_XMLUni_fgAttListString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgAttListString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgAttListString));
return 1;
}
@@ -2790,7 +2402,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgAttListString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgCommentString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgCommentString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgCommentString));
return 1;
}
@@ -2799,7 +2411,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgCommentString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgCDATAString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgCDATAString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgCDATAString));
return 1;
}
@@ -2808,7 +2420,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgCDATAString_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgDefaultString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDefaultString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDefaultString));
return 1;
}
@@ -2817,7 +2429,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDefaultString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgDocTypeString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDocTypeString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDocTypeString));
return 1;
}
@@ -2826,7 +2438,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDocTypeString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgEBCDICEncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEBCDICEncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEBCDICEncodingString));
return 1;
}
@@ -2835,7 +2447,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgEBCDICEncodingString_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgElemString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgElemString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgElemString));
return 1;
}
@@ -2844,7 +2456,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgElemString_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgEmptyString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEmptyString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEmptyString));
return 1;
}
@@ -2853,7 +2465,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgEmptyString_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgEncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEncodingString));
return 1;
}
@@ -2862,7 +2474,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgEncodingString_get(pTHX_ SV *sv, MAGIC *SWIG
SWIGCLASS_STATIC int _wrap_XMLUni_fgEntitString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEntitString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEntitString));
return 1;
}
@@ -2871,7 +2483,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgEntitString_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgEntityString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEntityString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEntityString));
return 1;
}
@@ -2880,7 +2492,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgEntityString_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgEntitiesString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEntitiesString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEntitiesString));
return 1;
}
@@ -2889,7 +2501,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgEntitiesString_get(pTHX_ SV *sv, MAGIC *SWIG
SWIGCLASS_STATIC int _wrap_XMLUni_fgEnumerationString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEnumerationString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEnumerationString));
return 1;
}
@@ -2898,7 +2510,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgEnumerationString_get(pTHX_ SV *sv, MAGIC *S
SWIGCLASS_STATIC int _wrap_XMLUni_fgExceptDomain_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgExceptDomain));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgExceptDomain));
return 1;
}
@@ -2907,7 +2519,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgExceptDomain_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgFixedString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgFixedString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgFixedString));
return 1;
}
@@ -2916,7 +2528,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgFixedString_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM037EncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM037EncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM037EncodingString));
return 1;
}
@@ -2925,7 +2537,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM037EncodingString_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM037EncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM037EncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM037EncodingString2));
return 1;
}
@@ -2934,7 +2546,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM037EncodingString2_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1047EncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1047EncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1047EncodingString));
return 1;
}
@@ -2943,7 +2555,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1047EncodingString_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1047EncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1047EncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1047EncodingString2));
return 1;
}
@@ -2952,7 +2564,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1047EncodingString2_get(pTHX_ SV *sv, MAG
SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1140EncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1140EncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1140EncodingString));
return 1;
}
@@ -2961,7 +2573,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1140EncodingString_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1140EncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1140EncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1140EncodingString2));
return 1;
}
@@ -2970,7 +2582,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1140EncodingString2_get(pTHX_ SV *sv, MAG
SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1140EncodingString3_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1140EncodingString3));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1140EncodingString3));
return 1;
}
@@ -2979,7 +2591,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1140EncodingString3_get(pTHX_ SV *sv, MAG
SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1140EncodingString4_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1140EncodingString4));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIBM1140EncodingString4));
return 1;
}
@@ -2988,7 +2600,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIBM1140EncodingString4_get(pTHX_ SV *sv, MAG
SWIGCLASS_STATIC int _wrap_XMLUni_fgIESString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIESString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIESString));
return 1;
}
@@ -2997,7 +2609,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIESString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSE
SWIGCLASS_STATIC int _wrap_XMLUni_fgIDString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIDString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIDString));
return 1;
}
@@ -3006,7 +2618,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIDString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSED
SWIGCLASS_STATIC int _wrap_XMLUni_fgIDRefString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIDRefString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIDRefString));
return 1;
}
@@ -3015,7 +2627,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIDRefString_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgIDRefsString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIDRefsString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIDRefsString));
return 1;
}
@@ -3024,7 +2636,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIDRefsString_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgImpliedString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgImpliedString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgImpliedString));
return 1;
}
@@ -3033,7 +2645,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgImpliedString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgIgnoreString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIgnoreString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIgnoreString));
return 1;
}
@@ -3042,7 +2654,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIgnoreString_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgIncludeString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIncludeString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIncludeString));
return 1;
}
@@ -3051,7 +2663,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIncludeString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString));
return 1;
}
@@ -3060,7 +2672,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString_get(pTHX_ SV *sv, MAG
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString2));
return 1;
}
@@ -3069,7 +2681,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString2_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString3_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString3));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString3));
return 1;
}
@@ -3078,7 +2690,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString3_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString4_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString4));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString4));
return 1;
}
@@ -3087,7 +2699,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString4_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString5_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString5));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString5));
return 1;
}
@@ -3096,7 +2708,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString5_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString6_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString6));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString6));
return 1;
}
@@ -3105,7 +2717,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString6_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString7_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString7));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString7));
return 1;
}
@@ -3114,7 +2726,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString7_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString8_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString8));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString8));
return 1;
}
@@ -3123,7 +2735,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString8_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString9_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString9));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString9));
return 1;
}
@@ -3132,7 +2744,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString9_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString10_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString10));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString10));
return 1;
}
@@ -3141,7 +2753,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString10_get(pTHX_ SV *sv, M
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString11_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString11));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString11));
return 1;
}
@@ -3150,7 +2762,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString11_get(pTHX_ SV *sv, M
SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString12_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString12));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgISO88591EncodingString12));
return 1;
}
@@ -3159,7 +2771,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgISO88591EncodingString12_get(pTHX_ SV *sv, M
SWIGCLASS_STATIC int _wrap_XMLUni_fgLocalHostString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgLocalHostString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgLocalHostString));
return 1;
}
@@ -3168,7 +2780,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgLocalHostString_get(pTHX_ SV *sv, MAGIC *SWI
SWIGCLASS_STATIC int _wrap_XMLUni_fgNoString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNoString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNoString));
return 1;
}
@@ -3177,7 +2789,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNoString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSED
SWIGCLASS_STATIC int _wrap_XMLUni_fgNotationString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNotationString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNotationString));
return 1;
}
@@ -3186,7 +2798,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNotationString_get(pTHX_ SV *sv, MAGIC *SWIG
SWIGCLASS_STATIC int _wrap_XMLUni_fgNDATAString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNDATAString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNDATAString));
return 1;
}
@@ -3195,7 +2807,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNDATAString_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgNmTokenString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNmTokenString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNmTokenString));
return 1;
}
@@ -3204,7 +2816,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNmTokenString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgNmTokensString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNmTokensString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNmTokensString));
return 1;
}
@@ -3213,7 +2825,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNmTokensString_get(pTHX_ SV *sv, MAGIC *SWIG
SWIGCLASS_STATIC int _wrap_XMLUni_fgPCDATAString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgPCDATAString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgPCDATAString));
return 1;
}
@@ -3222,7 +2834,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgPCDATAString_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgPIString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgPIString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgPIString));
return 1;
}
@@ -3231,7 +2843,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgPIString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSED
SWIGCLASS_STATIC int _wrap_XMLUni_fgPubIDString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgPubIDString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgPubIDString));
return 1;
}
@@ -3240,7 +2852,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgPubIDString_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgRefString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgRefString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgRefString));
return 1;
}
@@ -3249,7 +2861,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgRefString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSE
SWIGCLASS_STATIC int _wrap_XMLUni_fgRequiredString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgRequiredString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgRequiredString));
return 1;
}
@@ -3258,7 +2870,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgRequiredString_get(pTHX_ SV *sv, MAGIC *SWIG
SWIGCLASS_STATIC int _wrap_XMLUni_fgStandaloneString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgStandaloneString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgStandaloneString));
return 1;
}
@@ -3267,7 +2879,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgStandaloneString_get(pTHX_ SV *sv, MAGIC *SW
SWIGCLASS_STATIC int _wrap_XMLUni_fgVersion1_0_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgVersion1_0));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgVersion1_0));
return 1;
}
@@ -3276,7 +2888,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgVersion1_0_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgVersion1_1_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgVersion1_1));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgVersion1_1));
return 1;
}
@@ -3285,7 +2897,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgVersion1_1_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgSysIDString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSysIDString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSysIDString));
return 1;
}
@@ -3294,7 +2906,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgSysIDString_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgUnknownURIName_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUnknownURIName));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUnknownURIName));
return 1;
}
@@ -3303,7 +2915,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUnknownURIName_get(pTHX_ SV *sv, MAGIC *SWIG
SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4EncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4EncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4EncodingString));
return 1;
}
@@ -3312,7 +2924,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4EncodingString_get(pTHX_ SV *sv, MAGIC *
SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4EncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4EncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4EncodingString2));
return 1;
}
@@ -3321,7 +2933,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4EncodingString2_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4EncodingString3_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4EncodingString3));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4EncodingString3));
return 1;
}
@@ -3330,7 +2942,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4EncodingString3_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4BEncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4BEncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4BEncodingString));
return 1;
}
@@ -3339,7 +2951,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4BEncodingString_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4BEncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4BEncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4BEncodingString2));
return 1;
}
@@ -3348,7 +2960,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4BEncodingString2_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4LEncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4LEncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4LEncodingString));
return 1;
}
@@ -3357,7 +2969,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4LEncodingString_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4LEncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4LEncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUCS4LEncodingString2));
return 1;
}
@@ -3366,7 +2978,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUCS4LEncodingString2_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUSASCIIEncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUSASCIIEncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUSASCIIEncodingString));
return 1;
}
@@ -3375,7 +2987,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUSASCIIEncodingString_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgUSASCIIEncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUSASCIIEncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUSASCIIEncodingString2));
return 1;
}
@@ -3384,7 +2996,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUSASCIIEncodingString2_get(pTHX_ SV *sv, MAG
SWIGCLASS_STATIC int _wrap_XMLUni_fgUSASCIIEncodingString3_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUSASCIIEncodingString3));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUSASCIIEncodingString3));
return 1;
}
@@ -3393,7 +3005,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUSASCIIEncodingString3_get(pTHX_ SV *sv, MAG
SWIGCLASS_STATIC int _wrap_XMLUni_fgUSASCIIEncodingString4_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUSASCIIEncodingString4));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUSASCIIEncodingString4));
return 1;
}
@@ -3402,7 +3014,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUSASCIIEncodingString4_get(pTHX_ SV *sv, MAG
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF8EncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF8EncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF8EncodingString));
return 1;
}
@@ -3411,7 +3023,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF8EncodingString_get(pTHX_ SV *sv, MAGIC *
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF8EncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF8EncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF8EncodingString2));
return 1;
}
@@ -3420,7 +3032,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF8EncodingString2_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString));
return 1;
}
@@ -3429,7 +3041,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString2));
return 1;
}
@@ -3438,7 +3050,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString2_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString3_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString3));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString3));
return 1;
}
@@ -3447,7 +3059,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString3_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString4_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString4));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString4));
return 1;
}
@@ -3456,7 +3068,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString4_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString5_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString5));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString5));
return 1;
}
@@ -3465,7 +3077,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString5_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString6_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString6));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString6));
return 1;
}
@@ -3474,7 +3086,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString6_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString7_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString7));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16EncodingString7));
return 1;
}
@@ -3483,7 +3095,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16EncodingString7_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16BEncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16BEncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16BEncodingString));
return 1;
}
@@ -3492,7 +3104,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16BEncodingString_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16BEncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16BEncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16BEncodingString2));
return 1;
}
@@ -3501,7 +3113,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16BEncodingString2_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16LEncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16LEncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16LEncodingString));
return 1;
}
@@ -3510,7 +3122,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16LEncodingString_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16LEncodingString2_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16LEncodingString2));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTF16LEncodingString2));
return 1;
}
@@ -3519,7 +3131,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTF16LEncodingString2_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgVersionString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgVersionString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgVersionString));
return 1;
}
@@ -3528,7 +3140,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgVersionString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgValidityDomain_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgValidityDomain));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgValidityDomain));
return 1;
}
@@ -3537,7 +3149,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgValidityDomain_get(pTHX_ SV *sv, MAGIC *SWIG
SWIGCLASS_STATIC int _wrap_XMLUni_fgWin1252EncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgWin1252EncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgWin1252EncodingString));
return 1;
}
@@ -3546,7 +3158,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgWin1252EncodingString_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLChEncodingString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLChEncodingString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLChEncodingString));
return 1;
}
@@ -3555,7 +3167,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLChEncodingString_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDOMMsgDomain_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDOMMsgDomain));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDOMMsgDomain));
return 1;
}
@@ -3564,7 +3176,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDOMMsgDomain_get(pTHX_ SV *sv, MAGIC *SWI
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLString));
return 1;
}
@@ -3573,7 +3185,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSE
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringSpace_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringSpace));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringSpace));
return 1;
}
@@ -3582,7 +3194,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringSpace_get(pTHX_ SV *sv, MAGIC *SWIG
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringHTab_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringHTab));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringHTab));
return 1;
}
@@ -3591,7 +3203,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringHTab_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringCR_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringCR));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringCR));
return 1;
}
@@ -3600,7 +3212,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringCR_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringLF_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringLF));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringLF));
return 1;
}
@@ -3609,7 +3221,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringLF_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringSpaceU_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringSpaceU));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringSpaceU));
return 1;
}
@@ -3618,7 +3230,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringSpaceU_get(pTHX_ SV *sv, MAGIC *SWI
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringHTabU_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringHTabU));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringHTabU));
return 1;
}
@@ -3627,7 +3239,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringHTabU_get(pTHX_ SV *sv, MAGIC *SWIG
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringCRU_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringCRU));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringCRU));
return 1;
}
@@ -3636,7 +3248,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringCRU_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringLFU_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringLFU));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLStringLFU));
return 1;
}
@@ -3645,7 +3257,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLStringLFU_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclString));
return 1;
}
@@ -3654,7 +3266,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringSpace_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringSpace));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringSpace));
return 1;
}
@@ -3663,7 +3275,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringSpace_get(pTHX_ SV *sv, MAGIC *
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringHTab_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringHTab));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringHTab));
return 1;
}
@@ -3672,7 +3284,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringHTab_get(pTHX_ SV *sv, MAGIC *S
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringLF_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringLF));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringLF));
return 1;
}
@@ -3681,7 +3293,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringLF_get(pTHX_ SV *sv, MAGIC *SWI
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringCR_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringCR));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringCR));
return 1;
}
@@ -3690,7 +3302,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringCR_get(pTHX_ SV *sv, MAGIC *SWI
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringSpaceU_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringSpaceU));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringSpaceU));
return 1;
}
@@ -3699,7 +3311,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringSpaceU_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringHTabU_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringHTabU));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringHTabU));
return 1;
}
@@ -3708,7 +3320,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringHTabU_get(pTHX_ SV *sv, MAGIC *
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringLFU_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringLFU));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringLFU));
return 1;
}
@@ -3717,7 +3329,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringLFU_get(pTHX_ SV *sv, MAGIC *SW
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringCRU_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringCRU));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLDeclStringCRU));
return 1;
}
@@ -3726,7 +3338,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLDeclStringCRU_get(pTHX_ SV *sv, MAGIC *SW
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLNSString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLNSString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLNSString));
return 1;
}
@@ -3735,7 +3347,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLNSString_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLNSColonString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLNSColonString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLNSColonString));
return 1;
}
@@ -3744,7 +3356,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLNSColonString_get(pTHX_ SV *sv, MAGIC *SW
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLNSURIName_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLNSURIName));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLNSURIName));
return 1;
}
@@ -3753,7 +3365,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLNSURIName_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLErrDomain_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLErrDomain));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLErrDomain));
return 1;
}
@@ -3762,7 +3374,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLErrDomain_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLURIName_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLURIName));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLURIName));
return 1;
}
@@ -3771,7 +3383,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLURIName_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgInfosetURIName_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgInfosetURIName));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgInfosetURIName));
return 1;
}
@@ -3780,7 +3392,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgInfosetURIName_get(pTHX_ SV *sv, MAGIC *SWIG
SWIGCLASS_STATIC int _wrap_XMLUni_fgYesString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgYesString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgYesString));
return 1;
}
@@ -3789,7 +3401,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgYesString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSE
SWIGCLASS_STATIC int _wrap_XMLUni_fgZeroLenString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgZeroLenString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgZeroLenString));
return 1;
}
@@ -3798,7 +3410,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgZeroLenString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgDTDEntityString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDTDEntityString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDTDEntityString));
return 1;
}
@@ -3807,7 +3419,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDTDEntityString_get(pTHX_ SV *sv, MAGIC *SWI
SWIGCLASS_STATIC int _wrap_XMLUni_fgAmp_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgAmp));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgAmp));
return 1;
}
@@ -3816,7 +3428,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgAmp_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(
SWIGCLASS_STATIC int _wrap_XMLUni_fgLT_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgLT));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgLT));
return 1;
}
@@ -3825,7 +3437,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgLT_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(m
SWIGCLASS_STATIC int _wrap_XMLUni_fgGT_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgGT));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgGT));
return 1;
}
@@ -3834,7 +3446,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgGT_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(m
SWIGCLASS_STATIC int _wrap_XMLUni_fgQuot_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgQuot));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgQuot));
return 1;
}
@@ -3843,7 +3455,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgQuot_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM
SWIGCLASS_STATIC int _wrap_XMLUni_fgApos_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgApos));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgApos));
return 1;
}
@@ -3852,7 +3464,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgApos_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM
SWIGCLASS_STATIC int _wrap_XMLUni_fgWFXMLScanner_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgWFXMLScanner));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgWFXMLScanner));
return 1;
}
@@ -3861,7 +3473,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgWFXMLScanner_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgIGXMLScanner_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIGXMLScanner));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIGXMLScanner));
return 1;
}
@@ -3870,7 +3482,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIGXMLScanner_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgSGXMLScanner_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSGXMLScanner));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSGXMLScanner));
return 1;
}
@@ -3879,7 +3491,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgSGXMLScanner_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgDGXMLScanner_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDGXMLScanner));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDGXMLScanner));
return 1;
}
@@ -3888,7 +3500,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDGXMLScanner_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgXSAXMLScanner_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXSAXMLScanner));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXSAXMLScanner));
return 1;
}
@@ -3897,7 +3509,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXSAXMLScanner_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgCDataStart_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgCDataStart));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgCDataStart));
return 1;
}
@@ -3906,7 +3518,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgCDataStart_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgCDataEnd_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgCDataEnd));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgCDataEnd));
return 1;
}
@@ -3915,7 +3527,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgCDataEnd_get(pTHX_ SV *sv, MAGIC *SWIGUNUSED
SWIGCLASS_STATIC int _wrap_XMLUni_fgArrayIndexOutOfBoundsException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgArrayIndexOutOfBoundsException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgArrayIndexOutOfBoundsException_Name));
return 1;
}
@@ -3924,7 +3536,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgArrayIndexOutOfBoundsException_Name_get(pTHX
SWIGCLASS_STATIC int _wrap_XMLUni_fgEmptyStackException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEmptyStackException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEmptyStackException_Name));
return 1;
}
@@ -3933,7 +3545,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgEmptyStackException_Name_get(pTHX_ SV *sv, M
SWIGCLASS_STATIC int _wrap_XMLUni_fgIllegalArgumentException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIllegalArgumentException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIllegalArgumentException_Name));
return 1;
}
@@ -3942,7 +3554,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIllegalArgumentException_Name_get(pTHX_ SV *
SWIGCLASS_STATIC int _wrap_XMLUni_fgInvalidCastException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgInvalidCastException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgInvalidCastException_Name));
return 1;
}
@@ -3951,7 +3563,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgInvalidCastException_Name_get(pTHX_ SV *sv,
SWIGCLASS_STATIC int _wrap_XMLUni_fgIOException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIOException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIOException_Name));
return 1;
}
@@ -3960,7 +3572,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIOException_Name_get(pTHX_ SV *sv, MAGIC *SW
SWIGCLASS_STATIC int _wrap_XMLUni_fgNoSuchElementException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNoSuchElementException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNoSuchElementException_Name));
return 1;
}
@@ -3969,7 +3581,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNoSuchElementException_Name_get(pTHX_ SV *sv
SWIGCLASS_STATIC int _wrap_XMLUni_fgNullPointerException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNullPointerException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNullPointerException_Name));
return 1;
}
@@ -3978,7 +3590,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNullPointerException_Name_get(pTHX_ SV *sv,
SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLPlatformUtilsException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLPlatformUtilsException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXMLPlatformUtilsException_Name));
return 1;
}
@@ -3987,7 +3599,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXMLPlatformUtilsException_Name_get(pTHX_ SV
SWIGCLASS_STATIC int _wrap_XMLUni_fgRuntimeException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgRuntimeException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgRuntimeException_Name));
return 1;
}
@@ -3996,7 +3608,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgRuntimeException_Name_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgTranscodingException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgTranscodingException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgTranscodingException_Name));
return 1;
}
@@ -4005,7 +3617,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgTranscodingException_Name_get(pTHX_ SV *sv,
SWIGCLASS_STATIC int _wrap_XMLUni_fgUnexpectedEOFException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUnexpectedEOFException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUnexpectedEOFException_Name));
return 1;
}
@@ -4014,7 +3626,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUnexpectedEOFException_Name_get(pTHX_ SV *sv
SWIGCLASS_STATIC int _wrap_XMLUni_fgUnsupportedEncodingException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUnsupportedEncodingException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUnsupportedEncodingException_Name));
return 1;
}
@@ -4023,7 +3635,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUnsupportedEncodingException_Name_get(pTHX_
SWIGCLASS_STATIC int _wrap_XMLUni_fgUTFDataFormatException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTFDataFormatException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUTFDataFormatException_Name));
return 1;
}
@@ -4032,7 +3644,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUTFDataFormatException_Name_get(pTHX_ SV *sv
SWIGCLASS_STATIC int _wrap_XMLUni_fgNetAccessorException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNetAccessorException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNetAccessorException_Name));
return 1;
}
@@ -4041,7 +3653,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNetAccessorException_Name_get(pTHX_ SV *sv,
SWIGCLASS_STATIC int _wrap_XMLUni_fgMalformedURLException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgMalformedURLException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgMalformedURLException_Name));
return 1;
}
@@ -4050,7 +3662,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgMalformedURLException_Name_get(pTHX_ SV *sv,
SWIGCLASS_STATIC int _wrap_XMLUni_fgNumberFormatException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNumberFormatException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNumberFormatException_Name));
return 1;
}
@@ -4059,7 +3671,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNumberFormatException_Name_get(pTHX_ SV *sv,
SWIGCLASS_STATIC int _wrap_XMLUni_fgParseException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgParseException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgParseException_Name));
return 1;
}
@@ -4068,7 +3680,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgParseException_Name_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgInvalidDatatypeFacetException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgInvalidDatatypeFacetException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgInvalidDatatypeFacetException_Name));
return 1;
}
@@ -4077,7 +3689,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgInvalidDatatypeFacetException_Name_get(pTHX_
SWIGCLASS_STATIC int _wrap_XMLUni_fgInvalidDatatypeValueException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgInvalidDatatypeValueException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgInvalidDatatypeValueException_Name));
return 1;
}
@@ -4086,7 +3698,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgInvalidDatatypeValueException_Name_get(pTHX_
SWIGCLASS_STATIC int _wrap_XMLUni_fgSchemaDateTimeException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSchemaDateTimeException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSchemaDateTimeException_Name));
return 1;
}
@@ -4095,7 +3707,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgSchemaDateTimeException_Name_get(pTHX_ SV *s
SWIGCLASS_STATIC int _wrap_XMLUni_fgXPathException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXPathException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXPathException_Name));
return 1;
}
@@ -4104,7 +3716,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXPathException_Name_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgXSerializationException_Name_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXSerializationException_Name));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXSerializationException_Name));
return 1;
}
@@ -4113,7 +3725,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXSerializationException_Name_get(pTHX_ SV *s
SWIGCLASS_STATIC int _wrap_XMLUni_fgNegINFString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNegINFString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNegINFString));
return 1;
}
@@ -4122,7 +3734,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNegINFString_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgNegZeroString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNegZeroString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNegZeroString));
return 1;
}
@@ -4131,7 +3743,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNegZeroString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgPosZeroString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgPosZeroString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgPosZeroString));
return 1;
}
@@ -4140,7 +3752,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgPosZeroString_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgPosINFString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgPosINFString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgPosINFString));
return 1;
}
@@ -4149,7 +3761,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgPosINFString_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgNaNString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNaNString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNaNString));
return 1;
}
@@ -4158,7 +3770,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNaNString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSE
SWIGCLASS_STATIC int _wrap_XMLUni_fgEString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgEString));
return 1;
}
@@ -4167,7 +3779,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgEString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDP
SWIGCLASS_STATIC int _wrap_XMLUni_fgZeroString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgZeroString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgZeroString));
return 1;
}
@@ -4176,7 +3788,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgZeroString_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgNullString_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNullString));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNullString));
return 1;
}
@@ -4185,7 +3797,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNullString_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesDynamic_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesDynamic));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesDynamic));
return 1;
}
@@ -4194,7 +3806,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesDynamic_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSchema_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSchema));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSchema));
return 1;
}
@@ -4203,7 +3815,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSchema_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSchemaFullChecking_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSchemaFullChecking));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSchemaFullChecking));
return 1;
}
@@ -4212,7 +3824,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSchemaFullChecking_get(pTHX_ SV *sv, M
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesIdentityConstraintChecking_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesIdentityConstraintChecking));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesIdentityConstraintChecking));
return 1;
}
@@ -4221,7 +3833,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesIdentityConstraintChecking_get(pTHX_ S
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSchemaExternalSchemaLocation_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSchemaExternalSchemaLocation));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSchemaExternalSchemaLocation));
return 1;
}
@@ -4230,7 +3842,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSchemaExternalSchemaLocation_get(pTHX_
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSchemaExternalNoNameSpaceSchemaLocation_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation));
return 1;
}
@@ -4239,7 +3851,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSchemaExternalNoNameSpaceSchemaLocatio
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSecurityManager_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSecurityManager));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSecurityManager));
return 1;
}
@@ -4248,7 +3860,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSecurityManager_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesLoadExternalDTD_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesLoadExternalDTD));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesLoadExternalDTD));
return 1;
}
@@ -4257,7 +3869,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesLoadExternalDTD_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesContinueAfterFatalError_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesContinueAfterFatalError));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesContinueAfterFatalError));
return 1;
}
@@ -4266,7 +3878,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesContinueAfterFatalError_get(pTHX_ SV *
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesValidationErrorAsFatal_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesValidationErrorAsFatal));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesValidationErrorAsFatal));
return 1;
}
@@ -4275,7 +3887,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesValidationErrorAsFatal_get(pTHX_ SV *s
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesUserAdoptsDOMDocument_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesUserAdoptsDOMDocument));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesUserAdoptsDOMDocument));
return 1;
}
@@ -4284,7 +3896,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesUserAdoptsDOMDocument_get(pTHX_ SV *sv
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesCacheGrammarFromParse_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesCacheGrammarFromParse));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesCacheGrammarFromParse));
return 1;
}
@@ -4293,7 +3905,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesCacheGrammarFromParse_get(pTHX_ SV *sv
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesUseCachedGrammarInParse_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesUseCachedGrammarInParse));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesUseCachedGrammarInParse));
return 1;
}
@@ -4302,7 +3914,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesUseCachedGrammarInParse_get(pTHX_ SV *
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesScannerName_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesScannerName));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesScannerName));
return 1;
}
@@ -4311,7 +3923,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesScannerName_get(pTHX_ SV *sv, MAGIC *S
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesParserUseDocumentFromImplementation_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesParserUseDocumentFromImplementation));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesParserUseDocumentFromImplementation));
return 1;
}
@@ -4320,7 +3932,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesParserUseDocumentFromImplementation_ge
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesCalculateSrcOfs_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesCalculateSrcOfs));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesCalculateSrcOfs));
return 1;
}
@@ -4329,7 +3941,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesCalculateSrcOfs_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesStandardUriConformant_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesStandardUriConformant));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesStandardUriConformant));
return 1;
}
@@ -4338,7 +3950,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesStandardUriConformant_get(pTHX_ SV *sv
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesDOMHasPSVIInfo_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesDOMHasPSVIInfo));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesDOMHasPSVIInfo));
return 1;
}
@@ -4347,7 +3959,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesDOMHasPSVIInfo_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesGenerateSyntheticAnnotations_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesGenerateSyntheticAnnotations));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesGenerateSyntheticAnnotations));
return 1;
}
@@ -4356,7 +3968,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesGenerateSyntheticAnnotations_get(pTHX_
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesValidateAnnotations_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesValidateAnnotations));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesValidateAnnotations));
return 1;
}
@@ -4365,7 +3977,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesValidateAnnotations_get(pTHX_ SV *sv,
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesIgnoreCachedDTD_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesIgnoreCachedDTD));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesIgnoreCachedDTD));
return 1;
}
@@ -4374,7 +3986,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesIgnoreCachedDTD_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesIgnoreAnnotations_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesIgnoreAnnotations));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesIgnoreAnnotations));
return 1;
}
@@ -4383,7 +3995,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesIgnoreAnnotations_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesDisableDefaultEntityResolution_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesDisableDefaultEntityResolution));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesDisableDefaultEntityResolution));
return 1;
}
@@ -4392,7 +4004,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesDisableDefaultEntityResolution_get(pTH
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSkipDTDValidation_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSkipDTDValidation));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSkipDTDValidation));
return 1;
}
@@ -4401,7 +4013,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesSkipDTDValidation_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesEntityResolver_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesEntityResolver));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercesEntityResolver));
return 1;
}
@@ -4410,7 +4022,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercesEntityResolver_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgSAX2CoreValidation_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSAX2CoreValidation));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSAX2CoreValidation));
return 1;
}
@@ -4419,7 +4031,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgSAX2CoreValidation_get(pTHX_ SV *sv, MAGIC *
SWIGCLASS_STATIC int _wrap_XMLUni_fgSAX2CoreNameSpaces_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSAX2CoreNameSpaces));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSAX2CoreNameSpaces));
return 1;
}
@@ -4428,7 +4040,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgSAX2CoreNameSpaces_get(pTHX_ SV *sv, MAGIC *
SWIGCLASS_STATIC int _wrap_XMLUni_fgSAX2CoreNameSpacePrefixes_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSAX2CoreNameSpacePrefixes));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgSAX2CoreNameSpacePrefixes));
return 1;
}
@@ -4437,7 +4049,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgSAX2CoreNameSpacePrefixes_get(pTHX_ SV *sv,
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMCanonicalForm_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMCanonicalForm));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMCanonicalForm));
return 1;
}
@@ -4446,7 +4058,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMCanonicalForm_get(pTHX_ SV *sv, MAGIC *SW
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMCDATASections_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMCDATASections));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMCDATASections));
return 1;
}
@@ -4455,7 +4067,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMCDATASections_get(pTHX_ SV *sv, MAGIC *SW
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMComments_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMComments));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMComments));
return 1;
}
@@ -4464,7 +4076,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMComments_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMCharsetOverridesXMLEncoding_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMCharsetOverridesXMLEncoding));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMCharsetOverridesXMLEncoding));
return 1;
}
@@ -4473,7 +4085,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMCharsetOverridesXMLEncoding_get(pTHX_ SV
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMCheckCharacterNormalization_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMCheckCharacterNormalization));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMCheckCharacterNormalization));
return 1;
}
@@ -4482,7 +4094,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMCheckCharacterNormalization_get(pTHX_ SV
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMDatatypeNormalization_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMDatatypeNormalization));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMDatatypeNormalization));
return 1;
}
@@ -4491,7 +4103,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMDatatypeNormalization_get(pTHX_ SV *sv, M
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMDisallowDoctype_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMDisallowDoctype));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMDisallowDoctype));
return 1;
}
@@ -4500,7 +4112,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMDisallowDoctype_get(pTHX_ SV *sv, MAGIC *
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMElementContentWhitespace_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMElementContentWhitespace));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMElementContentWhitespace));
return 1;
}
@@ -4509,7 +4121,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMElementContentWhitespace_get(pTHX_ SV *sv
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMErrorHandler_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMErrorHandler));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMErrorHandler));
return 1;
}
@@ -4518,7 +4130,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMErrorHandler_get(pTHX_ SV *sv, MAGIC *SWI
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMEntities_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMEntities));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMEntities));
return 1;
}
@@ -4527,7 +4139,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMEntities_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMIgnoreUnknownCharacterDenormalization_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMIgnoreUnknownCharacterDenormalization));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMIgnoreUnknownCharacterDenormalization));
return 1;
}
@@ -4536,7 +4148,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMIgnoreUnknownCharacterDenormalization_get
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMInfoset_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMInfoset));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMInfoset));
return 1;
}
@@ -4545,7 +4157,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMInfoset_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMNamespaces_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMNamespaces));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMNamespaces));
return 1;
}
@@ -4554,7 +4166,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMNamespaces_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMNamespaceDeclarations_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMNamespaceDeclarations));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMNamespaceDeclarations));
return 1;
}
@@ -4563,7 +4175,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMNamespaceDeclarations_get(pTHX_ SV *sv, M
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMNormalizeCharacters_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMNormalizeCharacters));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMNormalizeCharacters));
return 1;
}
@@ -4572,7 +4184,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMNormalizeCharacters_get(pTHX_ SV *sv, MAG
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMResourceResolver_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMResourceResolver));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMResourceResolver));
return 1;
}
@@ -4581,7 +4193,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMResourceResolver_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMSchemaLocation_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMSchemaLocation));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMSchemaLocation));
return 1;
}
@@ -4590,7 +4202,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMSchemaLocation_get(pTHX_ SV *sv, MAGIC *S
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMSchemaType_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMSchemaType));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMSchemaType));
return 1;
}
@@ -4599,7 +4211,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMSchemaType_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMSplitCDATASections_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMSplitCDATASections));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMSplitCDATASections));
return 1;
}
@@ -4608,7 +4220,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMSplitCDATASections_get(pTHX_ SV *sv, MAGI
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMSupportedMediatypesOnly_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMSupportedMediatypesOnly));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMSupportedMediatypesOnly));
return 1;
}
@@ -4617,7 +4229,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMSupportedMediatypesOnly_get(pTHX_ SV *sv,
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMValidate_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMValidate));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMValidate));
return 1;
}
@@ -4626,7 +4238,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMValidate_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMValidateIfSchema_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMValidateIfSchema));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMValidateIfSchema));
return 1;
}
@@ -4635,7 +4247,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMValidateIfSchema_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWellFormed_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWellFormed));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWellFormed));
return 1;
}
@@ -4644,7 +4256,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWellFormed_get(pTHX_ SV *sv, MAGIC *SWIGU
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMXMLSchemaType_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMXMLSchemaType));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMXMLSchemaType));
return 1;
}
@@ -4653,7 +4265,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMXMLSchemaType_get(pTHX_ SV *sv, MAGIC *SW
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMDTDType_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMDTDType));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMDTDType));
return 1;
}
@@ -4662,7 +4274,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMDTDType_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTCanonicalForm_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTCanonicalForm));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTCanonicalForm));
return 1;
}
@@ -4671,7 +4283,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTCanonicalForm_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTDiscardDefaultContent_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTDiscardDefaultContent));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTDiscardDefaultContent));
return 1;
}
@@ -4680,7 +4292,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTDiscardDefaultContent_get(pTHX_ SV *sv
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTEntities_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTEntities));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTEntities));
return 1;
}
@@ -4689,7 +4301,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTEntities_get(pTHX_ SV *sv, MAGIC *SWIG
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTFormatPrettyPrint_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTFormatPrettyPrint));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTFormatPrettyPrint));
return 1;
}
@@ -4698,7 +4310,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTFormatPrettyPrint_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTNormalizeCharacters_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTNormalizeCharacters));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTNormalizeCharacters));
return 1;
}
@@ -4707,7 +4319,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTNormalizeCharacters_get(pTHX_ SV *sv,
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTSplitCdataSections_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTSplitCdataSections));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTSplitCdataSections));
return 1;
}
@@ -4716,7 +4328,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTSplitCdataSections_get(pTHX_ SV *sv, M
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTValidation_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTValidation));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTValidation));
return 1;
}
@@ -4725,7 +4337,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTValidation_get(pTHX_ SV *sv, MAGIC *SW
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTWhitespaceInElementContent_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTWhitespaceInElementContent));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTWhitespaceInElementContent));
return 1;
}
@@ -4734,7 +4346,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTWhitespaceInElementContent_get(pTHX_ S
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTBOM_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTBOM));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTBOM));
return 1;
}
@@ -4743,7 +4355,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTBOM_get(pTHX_ SV *sv, MAGIC *SWIGUNUSE
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMXMLDeclaration_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMXMLDeclaration));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMXMLDeclaration));
return 1;
}
@@ -4752,7 +4364,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMXMLDeclaration_get(pTHX_ SV *sv, MAGIC *S
SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTXercesPrettyPrint_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTXercesPrettyPrint));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDOMWRTXercesPrettyPrint));
return 1;
}
@@ -4761,7 +4373,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDOMWRTXercesPrettyPrint_get(pTHX_ SV *sv, MA
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercescInterfacePSVITypeInfo_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercescInterfacePSVITypeInfo));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercescInterfacePSVITypeInfo));
return 1;
}
@@ -4770,7 +4382,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercescInterfacePSVITypeInfo_get(pTHX_ SV *s
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercescInterfaceDOMDocumentTypeImpl_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercescInterfaceDOMDocumentTypeImpl));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercescInterfaceDOMDocumentTypeImpl));
return 1;
}
@@ -4779,7 +4391,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercescInterfaceDOMDocumentTypeImpl_get(pTHX
SWIGCLASS_STATIC int _wrap_XMLUni_fgXercescInterfaceDOMMemoryManager_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercescInterfaceDOMMemoryManager));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgXercescInterfaceDOMMemoryManager));
return 1;
}
@@ -4795,7 +4407,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgXercescDefaultLocale_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLUni_fgDefErrMsg_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDefErrMsg));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgDefErrMsg));
return 1;
}
@@ -4804,7 +4416,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgDefErrMsg_get(pTHX_ SV *sv, MAGIC *SWIGUNUSE
SWIGCLASS_STATIC int _wrap_XMLUni_fgValueZero_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgValueZero));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgValueZero));
return 1;
}
@@ -4813,7 +4425,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgValueZero_get(pTHX_ SV *sv, MAGIC *SWIGUNUSE
SWIGCLASS_STATIC int _wrap_XMLUni_fgNegOne_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNegOne));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgNegOne));
return 1;
}
@@ -4822,7 +4434,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgNegOne_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPA
SWIGCLASS_STATIC int _wrap_XMLUni_fgValueOne_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgValueOne));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgValueOne));
return 1;
}
@@ -4831,7 +4443,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgValueOne_get(pTHX_ SV *sv, MAGIC *SWIGUNUSED
SWIGCLASS_STATIC int _wrap_XMLUni_fgLongMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgLongMaxInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgLongMaxInc));
return 1;
}
@@ -4840,7 +4452,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgLongMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgLongMinInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgLongMinInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgLongMinInc));
return 1;
}
@@ -4849,7 +4461,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgLongMinInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgIntMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIntMaxInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIntMaxInc));
return 1;
}
@@ -4858,7 +4470,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIntMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSE
SWIGCLASS_STATIC int _wrap_XMLUni_fgIntMinInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIntMinInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgIntMinInc));
return 1;
}
@@ -4867,7 +4479,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgIntMinInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSE
SWIGCLASS_STATIC int _wrap_XMLUni_fgShortMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgShortMaxInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgShortMaxInc));
return 1;
}
@@ -4876,7 +4488,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgShortMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgShortMinInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgShortMinInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgShortMinInc));
return 1;
}
@@ -4885,7 +4497,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgShortMinInc_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgByteMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgByteMaxInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgByteMaxInc));
return 1;
}
@@ -4894,7 +4506,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgByteMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgByteMinInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgByteMinInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgByteMinInc));
return 1;
}
@@ -4903,7 +4515,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgByteMinInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgULongMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgULongMaxInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgULongMaxInc));
return 1;
}
@@ -4912,7 +4524,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgULongMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgUIntMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUIntMaxInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUIntMaxInc));
return 1;
}
@@ -4921,7 +4533,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUIntMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUS
SWIGCLASS_STATIC int _wrap_XMLUni_fgUShortMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUShortMaxInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUShortMaxInc));
return 1;
}
@@ -4930,7 +4542,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUShortMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUN
SWIGCLASS_STATIC int _wrap_XMLUni_fgUByteMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUByteMaxInc));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgUByteMaxInc));
return 1;
}
@@ -4939,7 +4551,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgUByteMaxInc_get(pTHX_ SV *sv, MAGIC *SWIGUNU
SWIGCLASS_STATIC int _wrap_XMLUni_fgLangPattern_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgLangPattern));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgLangPattern));
return 1;
}
@@ -4950,7 +4562,7 @@ SWIGCLASS_STATIC int _wrap_XMLUni_fgBooleanValueSpace_get(pTHX_ SV *sv, MAGIC *S
AV *myav = newAV();
for (int i=0;i<4;i++) {
- av_push(myav, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgBooleanValueSpace[i]));
+ av_push(myav, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLUni::fgBooleanValueSpace[i]));
}
SV* rv = newRV((SV*)myav);
@@ -4984,7 +4596,7 @@ SWIGCLASS_STATIC int _wrap_XMLElementDecl_fgPCDataElemId_get(pTHX_ SV *sv, MAGIC
SWIGCLASS_STATIC int _wrap_XMLElementDecl_fgPCDataElemName_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
MAGIC_PPERL
- sv_setsv((SV*)sv, XMLString2Perl(XERCES_CPP_NAMESPACE::XMLElementDecl::fgPCDataElemName));
+ sv_setsv((SV*)sv, UTF8_TRANSCODER->XMLString2Perl(XERCES_CPP_NAMESPACE::XMLElementDecl::fgPCDataElemName));
return 1;
}
@@ -5546,7 +5158,7 @@ XS(_wrap_delete_XMLPlatformUtils) {
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -5574,7 +5186,7 @@ XS(_wrap_XMLURL_lookupByName) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
{
@@ -5617,7 +5229,7 @@ XS(_wrap_XMLURL_parse) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLURL, 0 );
@@ -5692,7 +5304,7 @@ XS(_wrap_new_XMLURL__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
@@ -5701,7 +5313,7 @@ XS(_wrap_new_XMLURL__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -5758,7 +5370,7 @@ XS(_wrap_new_XMLURL__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -5800,7 +5412,7 @@ XS(_wrap_new_XMLURL__SWIG_3) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
{
@@ -6150,7 +5762,7 @@ XS(_wrap_XMLURL_getFragment) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -6187,7 +5799,7 @@ XS(_wrap_XMLURL_getHost) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -6224,7 +5836,7 @@ XS(_wrap_XMLURL_getPassword) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -6261,7 +5873,7 @@ XS(_wrap_XMLURL_getPath) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -6366,7 +5978,7 @@ XS(_wrap_XMLURL_getProtocolName) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -6403,7 +6015,7 @@ XS(_wrap_XMLURL_getQuery) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -6440,7 +6052,7 @@ XS(_wrap_XMLURL_getURLText) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -6477,7 +6089,7 @@ XS(_wrap_XMLURL_getUser) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -6546,7 +6158,7 @@ XS(_wrap_XMLURL_setURL__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -6596,7 +6208,7 @@ XS(_wrap_XMLURL_setURL__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -6605,7 +6217,7 @@ XS(_wrap_XMLURL_setURL__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -6671,7 +6283,7 @@ XS(_wrap_XMLURL_setURL__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -6727,7 +6339,7 @@ XS(_wrap_XMLURL_setURL__SWIG_3) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -6736,7 +6348,7 @@ XS(_wrap_XMLURL_setURL__SWIG_3) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
res4 = SWIG_ConvertPtr(ST(3), &argp4, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLURL, 0 );
@@ -7083,7 +6695,7 @@ XS(_wrap_XMLURL_makeRelativeTo__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -7251,7 +6863,7 @@ XS(_wrap_new_XMLUri__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
{
@@ -7299,7 +6911,7 @@ XS(_wrap_new_XMLUri__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -7421,7 +7033,7 @@ XS(_wrap_XMLUri_getUriText) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -7458,7 +7070,7 @@ XS(_wrap_XMLUri_getScheme) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -7495,7 +7107,7 @@ XS(_wrap_XMLUri_getUserInfo) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -7532,7 +7144,7 @@ XS(_wrap_XMLUri_getHost) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -7603,7 +7215,7 @@ XS(_wrap_XMLUri_getRegBasedAuthority) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -7640,7 +7252,7 @@ XS(_wrap_XMLUri_getPath) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -7677,7 +7289,7 @@ XS(_wrap_XMLUri_getQueryString) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -7714,7 +7326,7 @@ XS(_wrap_XMLUri_getFragment) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -7749,7 +7361,7 @@ XS(_wrap_XMLUri_setScheme) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -7798,7 +7410,7 @@ XS(_wrap_XMLUri_setUserInfo) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -7847,7 +7459,7 @@ XS(_wrap_XMLUri_setHost) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -7939,7 +7551,7 @@ XS(_wrap_XMLUri_setRegBasedAuthority) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -7988,7 +7600,7 @@ XS(_wrap_XMLUri_setPath) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -8037,7 +7649,7 @@ XS(_wrap_XMLUri_setQueryString) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -8086,7 +7698,7 @@ XS(_wrap_XMLUri_setFragment) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -8128,7 +7740,7 @@ XS(_wrap_XMLUri_isURIString) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
{
@@ -8179,7 +7791,7 @@ XS(_wrap_XMLUri_isValidURI__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -8236,7 +7848,7 @@ XS(_wrap_XMLUri_isValidURI__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -8289,7 +7901,7 @@ XS(_wrap_XMLUri_isValidURI__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -8346,7 +7958,7 @@ XS(_wrap_XMLUri_isValidURI__SWIG_3) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -8556,7 +8168,7 @@ XS(_wrap_XMLUri_normalizeURI) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XMLBuffer, 0 );
@@ -8740,7 +8352,7 @@ XS(_wrap_delete_XMLExcepts) {
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -8811,7 +8423,7 @@ XS(_wrap_XMLException_getType) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -8882,7 +8494,7 @@ XS(_wrap_XMLException_getMessage) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -9118,7 +8730,7 @@ XS(_wrap_delete_XMLUni) {
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -9174,7 +8786,7 @@ XS(_wrap_new_QName__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
@@ -9183,7 +8795,7 @@ XS(_wrap_new_QName__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -9239,7 +8851,7 @@ XS(_wrap_new_QName__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
@@ -9490,7 +9102,7 @@ XS(_wrap_QName_getPrefix) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -9527,7 +9139,7 @@ XS(_wrap_QName_getLocalPart) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -9598,7 +9210,7 @@ XS(_wrap_QName_getRawName) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -9671,7 +9283,7 @@ XS(_wrap_QName_setName__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -9680,7 +9292,7 @@ XS(_wrap_QName_setName__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
ecode4 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
@@ -9745,7 +9357,7 @@ XS(_wrap_QName_setName__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -9910,7 +9522,7 @@ XS(_wrap_QName_setPrefix) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -9959,7 +9571,7 @@ XS(_wrap_QName_setLocalPart) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -10011,7 +9623,7 @@ XS(_wrap_QName_setNPrefix) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -10070,7 +9682,7 @@ XS(_wrap_QName_setNLocalPart) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -10590,7 +10202,7 @@ XS(_wrap_XMLElementDecl_getFormattedContentModel) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -10627,7 +10239,7 @@ XS(_wrap_XMLElementDecl_getBaseName) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -10732,7 +10344,7 @@ XS(_wrap_XMLElementDecl_getFullName) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -10941,7 +10553,7 @@ XS(_wrap_XMLElementDecl_setElementName__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -10950,7 +10562,7 @@ XS(_wrap_XMLElementDecl_setElementName__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
@@ -11015,7 +10627,7 @@ XS(_wrap_XMLElementDecl_setElementName__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -11673,7 +11285,7 @@ XS(_wrap_XMLEntityDecl_getName) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -11710,7 +11322,7 @@ XS(_wrap_XMLEntityDecl_getNotationName) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -11747,7 +11359,7 @@ XS(_wrap_XMLEntityDecl_getPublicId) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -11784,7 +11396,7 @@ XS(_wrap_XMLEntityDecl_getSystemId) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -11821,7 +11433,7 @@ XS(_wrap_XMLEntityDecl_getBaseURI) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -11858,7 +11470,7 @@ XS(_wrap_XMLEntityDecl_getValue) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -12029,7 +11641,7 @@ XS(_wrap_XMLEntityDecl_setName) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -12078,7 +11690,7 @@ XS(_wrap_XMLEntityDecl_setNotationName) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -12127,7 +11739,7 @@ XS(_wrap_XMLEntityDecl_setPublicId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -12176,7 +11788,7 @@ XS(_wrap_XMLEntityDecl_setSystemId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -12225,7 +11837,7 @@ XS(_wrap_XMLEntityDecl_setBaseURI) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -12274,7 +11886,7 @@ XS(_wrap_XMLEntityDecl_setValue) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -12368,7 +11980,7 @@ XS(_wrap_XMLEntityDecl_getKey) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -12423,7 +12035,7 @@ XS(_wrap_new_XMLNotationDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
@@ -12432,7 +12044,7 @@ XS(_wrap_new_XMLNotationDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -12441,7 +12053,7 @@ XS(_wrap_new_XMLNotationDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -12450,7 +12062,7 @@ XS(_wrap_new_XMLNotationDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
{
@@ -12510,7 +12122,7 @@ XS(_wrap_new_XMLNotationDecl__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
@@ -12519,7 +12131,7 @@ XS(_wrap_new_XMLNotationDecl__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -12528,7 +12140,7 @@ XS(_wrap_new_XMLNotationDecl__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -12774,7 +12386,7 @@ XS(_wrap_XMLNotationDecl_getName) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -12811,7 +12423,7 @@ XS(_wrap_XMLNotationDecl_getPublicId) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -12848,7 +12460,7 @@ XS(_wrap_XMLNotationDecl_getSystemId) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -12885,7 +12497,7 @@ XS(_wrap_XMLNotationDecl_getBaseURI) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -13031,7 +12643,7 @@ XS(_wrap_XMLNotationDecl_setName) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -13080,7 +12692,7 @@ XS(_wrap_XMLNotationDecl_setPublicId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -13129,7 +12741,7 @@ XS(_wrap_XMLNotationDecl_setSystemId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -13178,7 +12790,7 @@ XS(_wrap_XMLNotationDecl_setBaseURI) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -13272,7 +12884,7 @@ XS(_wrap_XMLNotationDecl_getKey) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -13384,7 +12996,7 @@ XS(_wrap_XMLAttDefList_findAttDef__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -13437,7 +13049,7 @@ XS(_wrap_XMLAttDefList_findAttDef__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -13446,7 +13058,7 @@ XS(_wrap_XMLAttDefList_findAttDef__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -13717,7 +13329,7 @@ XS(_wrap_XMLAttDef_getAttTypeString) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -13754,7 +13366,7 @@ XS(_wrap_XMLAttDef_getDefAttTypeString) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -13825,7 +13437,7 @@ XS(_wrap_XMLAttDef_getFullName) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -13929,7 +13541,7 @@ XS(_wrap_XMLAttDef_getEnumeration) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -14034,7 +13646,7 @@ XS(_wrap_XMLAttDef_getValue) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -14300,7 +13912,7 @@ XS(_wrap_XMLAttDef_setValue) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -14349,7 +13961,7 @@ XS(_wrap_XMLAttDef_setEnumeration) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -14665,7 +14277,7 @@ XS(_wrap_Grammar_getTargetNamespace) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -14751,7 +14363,7 @@ XS(_wrap_Grammar_findOrAddElemDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -14760,7 +14372,7 @@ XS(_wrap_Grammar_findOrAddElemDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
@@ -14769,7 +14381,7 @@ XS(_wrap_Grammar_findOrAddElemDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
@@ -14862,7 +14474,7 @@ XS(_wrap_Grammar_getElemId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -14871,7 +14483,7 @@ XS(_wrap_Grammar_getElemId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
ecode5 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
@@ -14948,7 +14560,7 @@ XS(_wrap_Grammar_getElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -14957,7 +14569,7 @@ XS(_wrap_Grammar_getElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
ecode5 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
@@ -15176,7 +14788,7 @@ XS(_wrap_Grammar_getNotationDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -15242,7 +14854,7 @@ XS(_wrap_Grammar_putElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -15251,7 +14863,7 @@ XS(_wrap_Grammar_putElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
@@ -15260,7 +14872,7 @@ XS(_wrap_Grammar_putElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
@@ -15351,7 +14963,7 @@ XS(_wrap_Grammar_putElemDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -15360,7 +14972,7 @@ XS(_wrap_Grammar_putElemDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
@@ -15369,7 +14981,7 @@ XS(_wrap_Grammar_putElemDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
@@ -16127,7 +15739,7 @@ XS(_wrap_XMLGrammarDescription_getGrammarKey) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -16266,7 +15878,7 @@ XS(_wrap_XMLDTDDescription_getRootName) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -16303,7 +15915,7 @@ XS(_wrap_XMLDTDDescription_getSystemId) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -16338,7 +15950,7 @@ XS(_wrap_XMLDTDDescription_setRootName) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -16387,7 +15999,7 @@ XS(_wrap_XMLDTDDescription_setSystemId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -16540,7 +16152,7 @@ XS(_wrap_XMLSchemaDescription_getTargetNamespace) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -16754,7 +16366,7 @@ XS(_wrap_XMLSchemaDescription_setTargetNamespace) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -16803,7 +16415,7 @@ XS(_wrap_XMLSchemaDescription_setLocationHints) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -17276,7 +16888,7 @@ XS(_wrap_DTDElementDecl_getFormattedContentModel) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -17313,7 +16925,7 @@ XS(_wrap_DTDElementDecl_getKey) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -17349,7 +16961,7 @@ XS(_wrap_DTDElementDecl_getAttDef) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -18666,7 +18278,7 @@ XS(_wrap_DTDAttDefList_findAttDef__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -18719,7 +18331,7 @@ XS(_wrap_DTDAttDefList_findAttDef__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -18728,7 +18340,7 @@ XS(_wrap_DTDAttDefList_findAttDef__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -18999,7 +18611,7 @@ XS(_wrap_DTDAttDef_getFullName) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -19144,7 +18756,7 @@ XS(_wrap_DTDAttDef_setName) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -19287,7 +18899,7 @@ XS(_wrap_DTDGrammar_getTargetNamespace) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -19339,7 +18951,7 @@ XS(_wrap_DTDGrammar_findOrAddElemDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -19348,7 +18960,7 @@ XS(_wrap_DTDGrammar_findOrAddElemDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
@@ -19357,7 +18969,7 @@ XS(_wrap_DTDGrammar_findOrAddElemDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
@@ -19450,7 +19062,7 @@ XS(_wrap_DTDGrammar_getElemId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -19459,7 +19071,7 @@ XS(_wrap_DTDGrammar_getElemId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
ecode5 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
@@ -19536,7 +19148,7 @@ XS(_wrap_DTDGrammar_getElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -19545,7 +19157,7 @@ XS(_wrap_DTDGrammar_getElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
ecode5 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
@@ -19764,7 +19376,7 @@ XS(_wrap_DTDGrammar_getNotationDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -19864,7 +19476,7 @@ XS(_wrap_DTDGrammar_putElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -19873,7 +19485,7 @@ XS(_wrap_DTDGrammar_putElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
@@ -19882,7 +19494,7 @@ XS(_wrap_DTDGrammar_putElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
@@ -19973,7 +19585,7 @@ XS(_wrap_DTDGrammar_putElemDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -19982,7 +19594,7 @@ XS(_wrap_DTDGrammar_putElemDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
@@ -19991,7 +19603,7 @@ XS(_wrap_DTDGrammar_putElemDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
@@ -20520,7 +20132,7 @@ XS(_wrap_DTDGrammar_getEntityDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -21362,7 +20974,7 @@ XS(_wrap_SchemaElementDecl_getFormattedContentModel) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -21401,7 +21013,7 @@ XS(_wrap_SchemaElementDecl_getAttDef) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -21731,7 +21343,7 @@ XS(_wrap_SchemaElementDecl_getDefaultValue) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -22173,7 +21785,7 @@ XS(_wrap_SchemaElementDecl_setDefaultValue) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -23222,7 +22834,7 @@ XS(_wrap_SchemaGrammar_getTargetNamespace) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -23274,7 +22886,7 @@ XS(_wrap_SchemaGrammar_findOrAddElemDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -23283,7 +22895,7 @@ XS(_wrap_SchemaGrammar_findOrAddElemDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
@@ -23292,7 +22904,7 @@ XS(_wrap_SchemaGrammar_findOrAddElemDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
@@ -23385,7 +22997,7 @@ XS(_wrap_SchemaGrammar_getElemId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -23394,7 +23006,7 @@ XS(_wrap_SchemaGrammar_getElemId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
ecode5 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
@@ -23471,7 +23083,7 @@ XS(_wrap_SchemaGrammar_getElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -23480,7 +23092,7 @@ XS(_wrap_SchemaGrammar_getElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
ecode5 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
@@ -23699,7 +23311,7 @@ XS(_wrap_SchemaGrammar_getNotationDecl) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -23799,7 +23411,7 @@ XS(_wrap_SchemaGrammar_putElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -23808,7 +23420,7 @@ XS(_wrap_SchemaGrammar_putElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
@@ -23817,7 +23429,7 @@ XS(_wrap_SchemaGrammar_putElemDecl__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
@@ -23908,7 +23520,7 @@ XS(_wrap_SchemaGrammar_putElemDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
@@ -23917,7 +23529,7 @@ XS(_wrap_SchemaGrammar_putElemDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
@@ -23926,7 +23538,7 @@ XS(_wrap_SchemaGrammar_putElemDecl__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
ecode6 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
@@ -24794,7 +24406,7 @@ XS(_wrap_SchemaGrammar_setTargetNamespace) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -25730,7 +25342,7 @@ XS(_wrap_SchemaValidator_normalizeWhiteSpace) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
res4 = SWIG_ConvertPtr(ST(3), &argp4, SWIGTYPE_p_XMLBuffer, 0 );
@@ -25838,7 +25450,7 @@ XS(_wrap_SchemaValidator_setXsiType) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -25847,7 +25459,7 @@ XS(_wrap_SchemaValidator_setXsiType) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
ecode4 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
@@ -25995,7 +25607,7 @@ XS(_wrap_SchemaValidator_setDatatypeBuffer) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -26249,7 +25861,7 @@ XS(_wrap_SchemaValidator_getNormalizedValue) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -26361,7 +25973,7 @@ XS(_wrap_SchemaAttDefList_findAttDef__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -26414,7 +26026,7 @@ XS(_wrap_SchemaAttDefList_findAttDef__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -26423,7 +26035,7 @@ XS(_wrap_SchemaAttDefList_findAttDef__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -26586,7 +26198,7 @@ XS(_wrap_SchemaAttDefList_findAttDefLocalPart) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -26754,7 +26366,7 @@ XS(_wrap_SchemaAttDef_getFullName) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -27073,7 +26685,7 @@ XS(_wrap_SchemaAttDef_setAttName__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -27082,7 +26694,7 @@ XS(_wrap_SchemaAttDef_setAttName__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
@@ -27145,7 +26757,7 @@ XS(_wrap_SchemaAttDef_setAttName__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -27154,7 +26766,7 @@ XS(_wrap_SchemaAttDef_setAttName__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -27639,7 +27251,7 @@ XS(_wrap_InputSource_getEncoding) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -27676,7 +27288,7 @@ XS(_wrap_InputSource_getPublicId) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -27713,7 +27325,7 @@ XS(_wrap_InputSource_getSystemId) {
CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -27816,7 +27428,7 @@ XS(_wrap_InputSource_setEncoding) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -27865,7 +27477,7 @@ XS(_wrap_InputSource_setPublicId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -27914,7 +27526,7 @@ XS(_wrap_InputSource_setSystemId) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -28000,7 +27612,7 @@ XS(_wrap_new_LocalFileInputSource__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
@@ -28009,7 +27621,7 @@ XS(_wrap_new_LocalFileInputSource__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -28055,7 +27667,7 @@ XS(_wrap_new_LocalFileInputSource__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
{
@@ -28364,7 +27976,7 @@ XS(_wrap_new_URLInputSource__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
@@ -28373,7 +27985,7 @@ XS(_wrap_new_URLInputSource__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -28421,7 +28033,7 @@ XS(_wrap_new_URLInputSource__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
+ arg1 = UTF8_TRANSCODER->Perl2XMLString(ST(0));
}
@@ -28430,7 +28042,7 @@ XS(_wrap_new_URLInputSource__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -28439,7 +28051,7 @@ XS(_wrap_new_URLInputSource__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -28723,7 +28335,7 @@ XS(_wrap_new_MemBufInputSource) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(1));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -28906,129 +28518,105 @@ XS(_wrap_MemBufInputSource_resetMemBufInputSource) {
}
-XS(_wrap_new_DOMException__SWIG_0) {
+XS(_wrap_delete_SAXException) {
{
- short arg1 ;
- short arg2 ;
- XERCES_CPP_NAMESPACE::MemoryManager *arg3 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
- XERCES_CPP_NAMESPACE::DOMException *result = 0 ;
- short val1 ;
- int ecode1 = 0 ;
- short val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
+ XERCES_CPP_NAMESPACE::SAXException *arg1 = (XERCES_CPP_NAMESPACE::SAXException *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: new_DOMException(code,messageCode,memoryManager);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_SAXException(self);");
}
- ecode1 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMException" "', argument " "1"" of type '" "short""'");
- }
- arg1 = static_cast< short >(val1);
- ecode2 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DOMException" "', argument " "2"" of type '" "short""'");
- }
- arg2 = static_cast< short >(val2);
- res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DOMException" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SAXException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException *""'");
}
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp3);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXException * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMException *)new XERCES_CPP_NAMESPACE::DOMException(arg1,arg2,arg3);
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
XSRETURN(argvi);
fail:
-
-
SWIG_croak_null();
}
}
-XS(_wrap_new_DOMException__SWIG_1) {
+XS(_wrap_SAXException_getMessage) {
{
- short arg1 ;
- short arg2 ;
- XERCES_CPP_NAMESPACE::DOMException *result = 0 ;
- short val1 ;
- int ecode1 = 0 ;
- short val2 ;
- int ecode2 = 0 ;
+ XERCES_CPP_NAMESPACE::SAXException *arg1 = (XERCES_CPP_NAMESPACE::SAXException *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: new_DOMException(code,messageCode);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXException_getMessage(self);");
}
- ecode1 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMException" "', argument " "1"" of type '" "short""'");
- }
- arg1 = static_cast< short >(val1);
- ecode2 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DOMException" "', argument " "2"" of type '" "short""'");
- }
- arg2 = static_cast< short >(val2);
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXException_getMessage" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXException * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMException *)new XERCES_CPP_NAMESPACE::DOMException(arg1,arg2);
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXException const *)arg1)->getMessage();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
XSRETURN(argvi);
fail:
-
SWIG_croak_null();
}
}
-XS(_wrap_new_DOMException__SWIG_2) {
+XS(_wrap_new_SAXNotSupportedException) {
{
- short arg1 ;
- XERCES_CPP_NAMESPACE::DOMException *result = 0 ;
- short val1 ;
- int ecode1 = 0 ;
+ XERCES_CPP_NAMESPACE::SAXException *arg1 = 0 ;
+ XERCES_CPP_NAMESPACE::SAXNotSupportedException *result = 0 ;
+ void *argp1 ;
+ int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_DOMException(code);");
+ SWIG_croak("Usage: new_SAXNotSupportedException(toCopy);");
}
- ecode1 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMException" "', argument " "1"" of type '" "short""'");
- }
- arg1 = static_cast< short >(val1);
+ res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException, 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SAXNotSupportedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException const &""'");
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SAXNotSupportedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException const &""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXException * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMException *)new XERCES_CPP_NAMESPACE::DOMException(arg1);
+ result = (XERCES_CPP_NAMESPACE::SAXNotSupportedException *)new XERCES_CPP_NAMESPACE::SAXNotSupportedException((XERCES_CPP_NAMESPACE::SAXException const &)*arg1);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
fail:
@@ -29038,146 +28626,29 @@ XS(_wrap_new_DOMException__SWIG_2) {
}
-XS(_wrap_new_DOMException) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 1) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 3;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_3:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMException__SWIG_2); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMException__SWIG_1); return;
- case 3:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMException__SWIG_0); return;
- }
- }
-
- croak("No matching function for overloaded 'new_DOMException'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_delete_DOMException) {
+XS(_wrap_delete_SAXNotSupportedException) {
{
- XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXNotSupportedException *arg1 = (XERCES_CPP_NAMESPACE::SAXNotSupportedException *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMException(self);");
+ SWIG_croak("Usage: delete_SAXNotSupportedException(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SAXNotSupportedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXNotSupportedException *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXNotSupportedException * >(argp1);
{
try
{
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -29189,34 +28660,34 @@ XS(_wrap_delete_DOMException) {
}
-XS(_wrap_DOMException_getMessage) {
+XS(_wrap_new_SAXNotRecognizedException) {
{
- XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
+ XERCES_CPP_NAMESPACE::SAXException *arg1 = 0 ;
+ XERCES_CPP_NAMESPACE::SAXNotRecognizedException *result = 0 ;
+ void *argp1 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMException_getMessage(self);");
+ SWIG_croak("Usage: new_SAXNotRecognizedException(toCopy);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException, 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMException_getMessage" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SAXNotRecognizedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException const &""'");
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SAXNotRecognizedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException const &""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXException * >(argp1);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMException const *)arg1)->getMessage();
+ result = (XERCES_CPP_NAMESPACE::SAXNotRecognizedException *)new XERCES_CPP_NAMESPACE::SAXNotRecognizedException((XERCES_CPP_NAMESPACE::SAXException const &)*arg1);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
fail:
@@ -29226,63 +28697,65 @@ XS(_wrap_DOMException_getMessage) {
}
-XS(_wrap_DOMException_code_set) {
+XS(_wrap_delete_SAXNotRecognizedException) {
{
- XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
- XERCES_CPP_NAMESPACE::DOMException::ExceptionCode arg2 ;
+ XERCES_CPP_NAMESPACE::SAXNotRecognizedException *arg1 = (XERCES_CPP_NAMESPACE::SAXNotRecognizedException *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMException_code_set(self,code);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_SAXNotRecognizedException(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMException_code_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SAXNotRecognizedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXNotRecognizedException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXNotRecognizedException * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
- ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMException_code_set" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMException::ExceptionCode""'");
- }
- arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMException::ExceptionCode >(val2);
- if (arg1) (arg1)->code = arg2;
-
-
XSRETURN(argvi);
fail:
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMException_code_get) {
+XS(_wrap_delete_SAXParseException) {
{
- XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
- XERCES_CPP_NAMESPACE::DOMException::ExceptionCode result;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg1 = (XERCES_CPP_NAMESPACE::SAXParseException *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMException_code_get(self);");
+ SWIG_croak("Usage: delete_SAXParseException(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMException_code_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SAXParseException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
- result = (XERCES_CPP_NAMESPACE::DOMException::ExceptionCode) ((arg1)->code);
- ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
XSRETURN(argvi);
fail:
@@ -29292,72 +28765,65 @@ XS(_wrap_DOMException_code_get) {
}
-XS(_wrap_DOMException_msg_set) {
+XS(_wrap_SAXParseException_getColumnNumber) {
{
- XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg1 = (XERCES_CPP_NAMESPACE::SAXParseException *) 0 ;
+ XMLSSize_t result;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMException_msg_set(self,msg);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParseException_getColumnNumber(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMException_msg_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParseException_getColumnNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMException_msg_set");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::SAXParseException const *)arg1)->getColumnNumber();
+ }
+ CATCH_XML_EXCEPTION
}
-
- if (arg1) (arg1)->msg = (XMLCh const *)arg2;
-
-
-
-
- delete[] arg2;
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
XSRETURN(argvi);
fail:
-
- delete[] arg2;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMException_msg_get) {
+XS(_wrap_SAXParseException_getLineNumber) {
{
- XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg1 = (XERCES_CPP_NAMESPACE::SAXParseException *) 0 ;
+ XMLSSize_t result;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMException_msg_get(self);");
+ SWIG_croak("Usage: SAXParseException_getLineNumber(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMException_msg_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMException *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParseException_getLineNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMException * >(argp1);
- result = (XMLCh *) ((arg1)->msg);
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp1);
+ {
+ try
+ {
+ result = ((XERCES_CPP_NAMESPACE::SAXParseException const *)arg1)->getLineNumber();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
XSRETURN(argvi);
fail:
@@ -29367,31 +28833,34 @@ XS(_wrap_DOMException_msg_get) {
}
-XS(_wrap_delete_DOMNode) {
+XS(_wrap_SAXParseException_getPublicId) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg1 = (XERCES_CPP_NAMESPACE::SAXParseException *) 0 ;
+ XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMNode(self);");
+ SWIG_croak("Usage: SAXParseException_getPublicId(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParseException_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp1);
{
try
{
- delete arg1;
-
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXParseException const *)arg1)->getPublicId();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
XSRETURN(argvi);
fail:
@@ -29401,9 +28870,9 @@ XS(_wrap_delete_DOMNode) {
}
-XS(_wrap_DOMNode_getNodeName) {
+XS(_wrap_SAXParseException_getSystemId) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg1 = (XERCES_CPP_NAMESPACE::SAXParseException *) 0 ;
XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -29411,22 +28880,22 @@ XS(_wrap_DOMNode_getNodeName) {
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getNodeName(self);");
+ SWIG_croak("Usage: SAXParseException_getSystemId(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getNodeName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParseException_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp1);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNodeName();
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXParseException const *)arg1)->getSystemId();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -29438,34 +28907,31 @@ XS(_wrap_DOMNode_getNodeName) {
}
-XS(_wrap_DOMNode_getNodeValue) {
+XS(_wrap_delete_ErrorHandler) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::ErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::ErrorHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getNodeValue(self);");
+ SWIG_croak("Usage: delete_ErrorHandler(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getNodeValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp1);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNodeValue();
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
XSRETURN(argvi);
fail:
@@ -29475,133 +28941,168 @@ XS(_wrap_DOMNode_getNodeValue) {
}
-XS(_wrap_DOMNode_getNodeType) {
+XS(_wrap_ErrorHandler_warning) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- short result;
+ XERCES_CPP_NAMESPACE::ErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::ErrorHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- int argvi = 0;
+ void *argp2 ;
+ int res2 = 0 ;
+ int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getNodeType(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ErrorHandler_warning(self,exc);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getNodeType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ErrorHandler_warning" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ErrorHandler_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ErrorHandler_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
{
try
{
- result = (short)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNodeType();
+ (arg1)->warning((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
+
+
XSRETURN(argvi);
fail:
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_getParentNode) {
+XS(_wrap_ErrorHandler_error) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::ErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::ErrorHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getParentNode(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ErrorHandler_error(self,exc);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getParentNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ErrorHandler_error" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ErrorHandler_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ErrorHandler_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getParentNode();
+ (arg1)->error((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
XSRETURN(argvi);
fail:
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_getChildNodes) {
+XS(_wrap_ErrorHandler_fatalError) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
+ XERCES_CPP_NAMESPACE::ErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::ErrorHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getChildNodes(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ErrorHandler_fatalError(self,exc);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getChildNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ErrorHandler_fatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ErrorHandler_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ErrorHandler_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getChildNodes();
+ (arg1)->fatalError((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | SWIG_SHADOW); argvi++ ;
+
+
XSRETURN(argvi);
fail:
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_getFirstChild) {
+XS(_wrap_ErrorHandler_resetErrors) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::ErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::ErrorHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getFirstChild(self);");
+ SWIG_croak("Usage: ErrorHandler_resetErrors(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getFirstChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ErrorHandler_resetErrors" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getFirstChild();
+ (arg1)->resetErrors();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
XSRETURN(argvi);
fail:
@@ -29611,31 +29112,31 @@ XS(_wrap_DOMNode_getFirstChild) {
}
-XS(_wrap_DOMNode_getLastChild) {
+XS(_wrap_delete_DTDHandler) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DTDHandler *arg1 = (XERCES_CPP_NAMESPACE::DTDHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getLastChild(self);");
+ SWIG_croak("Usage: delete_DTDHandler(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getLastChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DTDHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DTDHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DTDHandler * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getLastChild();
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
XSRETURN(argvi);
fail:
@@ -29645,343 +29146,265 @@ XS(_wrap_DOMNode_getLastChild) {
}
-XS(_wrap_DOMNode_getPreviousSibling) {
+XS(_wrap_DTDHandler_unparsedEntityDecl) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DTDHandler *arg1 = (XERCES_CPP_NAMESPACE::DTDHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getPreviousSibling(self);");
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: DTDHandler_unparsedEntityDecl(self,name,publicId,systemId,notationName);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getPreviousSibling" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTDHandler_unparsedEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DTDHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getPreviousSibling();
- }
- CATCH_DOM_EXCEPTION
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DTDHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DTDHandler_unparsedEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNode_getNextSibling) {
- {
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DTDHandler_unparsedEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getNextSibling(self);");
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DTDHandler_unparsedEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getNextSibling" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+
+
+ if (ST(4) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",5,"DTDHandler_unparsedEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNextSibling();
+ (arg1)->unparsedEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNode_getAttributes) {
- {
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getAttributes(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getAttributes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getAttributes();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | SWIG_SHADOW); argvi++ ;
+ delete[] arg2;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNode_getOwnerDocument) {
- {
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
+ delete[] arg3;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getOwnerDocument(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getOwnerDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocument *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getOwnerDocument();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg4;
+
+
+ delete[] arg5;
XSRETURN(argvi);
fail:
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+
+ delete[] arg5;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_cloneNode) {
+XS(_wrap_delete_DocumentHandler) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- bool arg2 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DocumentHandler *arg1 = (XERCES_CPP_NAMESPACE::DocumentHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_cloneNode(self,deep);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DocumentHandler(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_cloneNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DocumentHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DocumentHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMNode_cloneNode" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DocumentHandler * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->cloneNode(arg2);
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
fail:
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_insertBefore) {
+XS(_wrap_DocumentHandler_characters) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg3 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DocumentHandler *arg1 = (XERCES_CPP_NAMESPACE::DocumentHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ unsigned int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMNode_insertBefore(self,newChild,refChild);");
+ SWIG_croak("Usage: DocumentHandler_characters(self,chars,length);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_insertBefore" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_insertBefore" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DocumentHandler_characters" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DocumentHandler *""'");
}
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMNode_insertBefore" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DocumentHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DocumentHandler_characters");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp3);
+
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DocumentHandler_characters" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->insertBefore(arg2,arg3);
+ (arg1)->characters((XMLCh const *)arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+ delete[] arg2;
+
+
XSRETURN(argvi);
fail:
+ delete[] arg2;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_replaceChild) {
+XS(_wrap_DocumentHandler_processingInstruction) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg3 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DocumentHandler *arg1 = (XERCES_CPP_NAMESPACE::DocumentHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMNode_replaceChild(self,newChild,oldChild);");
+ SWIG_croak("Usage: DocumentHandler_processingInstruction(self,target,data);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_replaceChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DocumentHandler_processingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DocumentHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_replaceChild" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DocumentHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DocumentHandler_processingInstruction");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMNode_replaceChild" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DocumentHandler_processingInstruction");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp3);
+
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->replaceChild(arg2,arg3);
+ (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
+ delete[] arg2;
+ delete[] arg3;
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNode_removeChild) {
- {
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
+ XSRETURN(argvi);
+ fail:
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_removeChild(self,oldChild);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_removeChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_removeChild" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->removeChild(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+ delete[] arg2;
- XSRETURN(argvi);
- fail:
+ delete[] arg3;
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_appendChild) {
+XS(_wrap_DocumentHandler_setDocumentLocator) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DocumentHandler *arg1 = (XERCES_CPP_NAMESPACE::DocumentHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::Locator *arg2 = (XERCES_CPP_NAMESPACE::Locator *) (XERCES_CPP_NAMESPACE::Locator *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
@@ -29990,26 +29413,26 @@ XS(_wrap_DOMNode_appendChild) {
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_appendChild(self,newChild);");
+ SWIG_croak("Usage: DocumentHandler_setDocumentLocator(self,locator);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_appendChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DocumentHandler_setDocumentLocator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DocumentHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DocumentHandler * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_appendChild" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DocumentHandler_setDocumentLocator" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::Locator const *const""'");
}
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp2);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->appendChild(arg2);
+ (arg1)->setDocumentLocator((XERCES_CPP_NAMESPACE::Locator const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
XSRETURN(argvi);
@@ -30021,31 +29444,31 @@ XS(_wrap_DOMNode_appendChild) {
}
-XS(_wrap_DOMNode_hasChildNodes) {
+XS(_wrap_delete_EntityResolver) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- bool result;
+ XERCES_CPP_NAMESPACE::EntityResolver *arg1 = (XERCES_CPP_NAMESPACE::EntityResolver *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_hasChildNodes(self);");
+ SWIG_croak("Usage: delete_EntityResolver(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__EntityResolver, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_hasChildNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::EntityResolver *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::EntityResolver * >(argp1);
{
try
{
- result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->hasChildNodes();
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
XSRETURN(argvi);
fail:
@@ -30055,79 +29478,65 @@ XS(_wrap_DOMNode_hasChildNodes) {
}
-XS(_wrap_DOMNode_setNodeValue) {
+XS(_wrap_delete_AttributeList) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_setNodeValue(self,nodeValue);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_AttributeList(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_setNodeValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNode_setNodeValue");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AttributeList" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList *""'");
}
-
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
{
try
{
- (arg1)->setNodeValue((XMLCh const *)arg2);
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
-
- delete[] arg2;
-
XSRETURN(argvi);
fail:
-
- delete[] arg2;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_normalize) {
+XS(_wrap_AttributeList_getLength) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
+ unsigned int result;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_normalize(self);");
+ SWIG_croak("Usage: AttributeList_getLength(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_normalize" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
{
try
{
- (arg1)->normalize();
+ result = (unsigned int)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getLength();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
-
+ ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
XSRETURN(argvi);
fail:
@@ -30137,180 +29546,185 @@ XS(_wrap_DOMNode_normalize) {
}
-XS(_wrap_DOMNode_isSupported) {
+XS(_wrap_AttributeList_getName) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- bool result;
+ XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
+ unsigned int arg2 ;
+ XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMNode_isSupported(self,feature,version);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AttributeList_getName(self,index);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_isSupported" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNode_isSupported");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMNode_isSupported");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
}
-
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttributeList_getName" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
{
try
{
- result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isSupported((XMLCh const *)arg2,(XMLCh const *)arg3);
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getName(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- delete[] arg2;
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
- delete[] arg3;
XSRETURN(argvi);
fail:
- delete[] arg2;
-
-
- delete[] arg3;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_getNamespaceURI) {
+XS(_wrap_AttributeList_getType__SWIG_0) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
+ unsigned int arg2 ;
XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getNamespaceURI(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AttributeList_getType(self,index);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getNamespaceURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttributeList_getType" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNamespaceURI();
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getType(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
+
XSRETURN(argvi);
fail:
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_getLocalName) {
+XS(_wrap_AttributeList_getValue__SWIG_0) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+ XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
+ unsigned int arg2 ;
XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getLocalName(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: AttributeList_getValue(self,index);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getLocalName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttributeList_getValue" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getLocalName();
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getValue(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
+
XSRETURN(argvi);
fail:
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_setPrefix) {
+XS(_wrap_AttributeList_getType__SWIG_1) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_setPrefix(self,prefix);");
+ SWIG_croak("Usage: AttributeList_getType(self,name);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_setPrefix" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNode_setPrefix");
+ SWIG_Perl_NullRef("perl-string",2,"AttributeList_getType");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
try
{
- (arg1)->setPrefix((XMLCh const *)arg2);
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getType((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
delete[] arg2;
@@ -30326,181 +29740,266 @@ XS(_wrap_DOMNode_setPrefix) {
}
-XS(_wrap_DOMNode_hasAttributes) {
+XS(_wrap_AttributeList_getType) {
+ dXSARGS;
+
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_hasAttributes(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_hasAttributes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- {
- try
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
{
- result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->hasAttributes();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
- XSRETURN(argvi);
- fail:
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
- SWIG_croak_null();
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AttributeList_getType__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AttributeList_getType__SWIG_1); return;
+ }
}
+
+ croak("No matching function for overloaded 'AttributeList_getType'");
+ XSRETURN(0);
}
-XS(_wrap_DOMNode_isSameNode) {
+XS(_wrap_AttributeList_getValue__SWIG_1) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- bool result;
+ XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_isSameNode(self,other);");
+ SWIG_croak("Usage: AttributeList_getValue(self,name);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_isSameNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_isSameNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"AttributeList_getValue");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+
{
try
{
- result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isSameNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getValue((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
+
+ delete[] arg2;
XSRETURN(argvi);
fail:
+ delete[] arg2;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_isEqualNode) {
+XS(_wrap_AttributeList_getValue) {
+ dXSARGS;
+
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_isEqualNode(self,arg);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_isEqualNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_isEqualNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
{
- result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isEqualNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
}
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
+ check_1:
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
- SWIG_croak_null();
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AttributeList_getValue__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AttributeList_getValue__SWIG_1); return;
+ }
}
+
+ croak("No matching function for overloaded 'AttributeList_getValue'");
+ XSRETURN(0);
}
-XS(_wrap_DOMNode_setUserData) {
+XS(_wrap_HandlerBase_characters) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *arg3 = (void *) 0 ;
- XERCES_CPP_NAMESPACE::DOMUserDataHandler *arg4 = (XERCES_CPP_NAMESPACE::DOMUserDataHandler *) 0 ;
- void *result = 0 ;
+ XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ unsigned int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMNode_setUserData(self,key,data,handler);");
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: HandlerBase_characters(self,chars,length);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_setUserData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_characters" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNode_setUserData");
+ SWIG_Perl_NullRef("perl-string",2,"HandlerBase_characters");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- {
- arg3 = (void*) ST(2);
- }
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMNode_setUserData" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::DOMUserDataHandler *""'");
- }
- arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMUserDataHandler * >(argp4);
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HandlerBase_characters" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
{
try
{
- result = (void *)(arg1)->setUserData((XMLCh const *)arg2,arg3,arg4);
+ (arg1)->characters((XMLCh const *)arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
- delete[] arg2;
-
- delete[] arg3;
+ delete[] arg2;
XSRETURN(argvi);
@@ -30510,106 +30009,80 @@ XS(_wrap_DOMNode_setUserData) {
delete[] arg2;
- delete[] arg3;
-
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_getUserData) {
+XS(_wrap_HandlerBase_processingInstruction) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *result = 0 ;
+ XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_getUserData(self,key);");
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: HandlerBase_processingInstruction(self,target,data);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getUserData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_processingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNode_getUserData");
+ SWIG_Perl_NullRef("perl-string",2,"HandlerBase_processingInstruction");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"HandlerBase_processingInstruction");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
try
{
- result = (void *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getUserData((XMLCh const *)arg2);
+ (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
delete[] arg2;
+
+ delete[] arg3;
+
XSRETURN(argvi);
fail:
delete[] arg2;
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNode_getBaseURI) {
- {
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getBaseURI(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getBaseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getBaseURI();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
- XSRETURN(argvi);
- fail:
+ delete[] arg3;
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_compareDocumentPosition) {
+XS(_wrap_HandlerBase_setDocumentLocator) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- short result;
+ XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
+ XERCES_CPP_NAMESPACE::Locator *arg2 = (XERCES_CPP_NAMESPACE::Locator *) (XERCES_CPP_NAMESPACE::Locator *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
@@ -30618,26 +30091,26 @@ XS(_wrap_DOMNode_compareDocumentPosition) {
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_compareDocumentPosition(self,other);");
+ SWIG_croak("Usage: HandlerBase_setDocumentLocator(self,locator);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_compareDocumentPosition" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_setDocumentLocator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode_compareDocumentPosition" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HandlerBase_setDocumentLocator" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::Locator const *const""'");
}
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp2);
{
try
{
- result = (short)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->compareDocumentPosition((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ (arg1)->setDocumentLocator((XERCES_CPP_NAMESPACE::Locator const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
+
XSRETURN(argvi);
@@ -30649,293 +30122,241 @@ XS(_wrap_DOMNode_compareDocumentPosition) {
}
-XS(_wrap_DOMNode_getTextContent) {
+XS(_wrap_HandlerBase_error) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_getTextContent(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: HandlerBase_error(self,exc);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getTextContent" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_error" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HandlerBase_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HandlerBase_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getTextContent();
+ (arg1)->error((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
XSRETURN(argvi);
fail:
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_setTextContent) {
+XS(_wrap_HandlerBase_fatalError) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_setTextContent(self,textContent);");
+ SWIG_croak("Usage: HandlerBase_fatalError(self,exc);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_setTextContent" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_fatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNode_setTextContent");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HandlerBase_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
}
-
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HandlerBase_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
{
try
{
- (arg1)->setTextContent((XMLCh const *)arg2);
+ (arg1)->fatalError((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- delete[] arg2;
-
XSRETURN(argvi);
fail:
- delete[] arg2;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_lookupPrefix) {
+XS(_wrap_HandlerBase_warning) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_lookupPrefix(self,namespaceURI);");
+ SWIG_croak("Usage: HandlerBase_warning(self,exc);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_lookupPrefix" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_warning" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNode_lookupPrefix");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HandlerBase_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
}
-
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HandlerBase_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->lookupPrefix((XMLCh const *)arg2);
+ (arg1)->warning((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
- delete[] arg2;
-
XSRETURN(argvi);
fail:
- delete[] arg2;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_isDefaultNamespace) {
+XS(_wrap_HandlerBase_resetErrors) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- bool result;
+ XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_isDefaultNamespace(self,namespaceURI);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: HandlerBase_resetErrors(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_isDefaultNamespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNode_isDefaultNamespace");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_resetErrors" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
}
-
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
{
try
{
- result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isDefaultNamespace((XMLCh const *)arg2);
+ (arg1)->resetErrors();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
- delete[] arg2;
-
XSRETURN(argvi);
fail:
-
- delete[] arg2;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_lookupNamespaceURI) {
+XS(_wrap_HandlerBase_unparsedEntityDecl) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode_lookupNamespaceURI(self,prefix);");
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: HandlerBase_unparsedEntityDecl(self,name,publicId,systemId,notationName);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_lookupNamespaceURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_unparsedEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNode_lookupNamespaceURI");
+ SWIG_Perl_NullRef("perl-string",2,"HandlerBase_unparsedEntityDecl");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->lookupNamespaceURI((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNode_getFeature) {
- {
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- void *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMNode_getFeature(self,feature,version);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_getFeature" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"HandlerBase_unparsedEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNode_getFeature");
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"HandlerBase_unparsedEntityDecl");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMNode_getFeature");
+ if (ST(4) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",5,"HandlerBase_unparsedEntityDecl");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
{
try
{
- result = (void *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getFeature((XMLCh const *)arg2,(XMLCh const *)arg3);
+ (arg1)->unparsedEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
+
delete[] arg2;
@@ -30943,6 +30364,12 @@ XS(_wrap_DOMNode_getFeature) {
delete[] arg3;
+
+ delete[] arg4;
+
+
+ delete[] arg5;
+
XSRETURN(argvi);
fail:
@@ -30952,155 +30379,98 @@ XS(_wrap_DOMNode_getFeature) {
delete[] arg3;
+
+ delete[] arg4;
+
+
+ delete[] arg5;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode_release) {
+XS(_wrap_new_HandlerBase) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
+ XERCES_CPP_NAMESPACE::HandlerBase *result = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNode_release(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_HandlerBase();");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
{
try
{
- (arg1)->release();
+ result = (XERCES_CPP_NAMESPACE::HandlerBase *)new XERCES_CPP_NAMESPACE::HandlerBase();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
-
-
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
fail:
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMNode___eq__) {
+XS(_wrap_delete_HandlerBase) {
{
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- bool result;
+ XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode___eq__(self,other);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_HandlerBase(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode___eq__" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode___eq__" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HandlerBase" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
}
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
{
try
{
- result = (bool)XERCES_CPP_NAMESPACE_DOMNode_operator_Se__Se_(arg1,(XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNode___ne__) {
- {
- XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNode___ne__(self,other);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNode___ne__" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNode___ne__" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- result = (bool)XERCES_CPP_NAMESPACE_DOMNode_operator_SN__Se_(arg1,(XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
XSRETURN(argvi);
fail:
-
SWIG_croak_null();
}
}
-XS(_wrap_delete_DOMAttr) {
+XS(_wrap_delete_Locator) {
{
- XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ XERCES_CPP_NAMESPACE::Locator *arg1 = (XERCES_CPP_NAMESPACE::Locator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMAttr(self);");
+ SWIG_croak("Usage: delete_Locator(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMAttr" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Locator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Locator *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp1);
{
try
{
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -31112,9 +30482,9 @@ XS(_wrap_delete_DOMAttr) {
}
-XS(_wrap_DOMAttr_getName) {
+XS(_wrap_Locator_getPublicId) {
{
- XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ XERCES_CPP_NAMESPACE::Locator *arg1 = (XERCES_CPP_NAMESPACE::Locator *) 0 ;
XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -31122,22 +30492,22 @@ XS(_wrap_DOMAttr_getName) {
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMAttr_getName(self);");
+ SWIG_croak("Usage: Locator_getPublicId(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_getName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locator_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Locator const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp1);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getName();
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Locator const *)arg1)->getPublicId();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -31149,43 +30519,9 @@ XS(_wrap_DOMAttr_getName) {
}
-XS(_wrap_DOMAttr_getSpecified) {
- {
- XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMAttr_getSpecified(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_getSpecified" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getSpecified();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMAttr_getValue) {
+XS(_wrap_Locator_getSystemId) {
{
- XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+ XERCES_CPP_NAMESPACE::Locator *arg1 = (XERCES_CPP_NAMESPACE::Locator *) 0 ;
XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -31193,22 +30529,22 @@ XS(_wrap_DOMAttr_getValue) {
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMAttr_getValue(self);");
+ SWIG_croak("Usage: Locator_getSystemId(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locator_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Locator const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp1);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getValue();
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Locator const *)arg1)->getSystemId();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -31220,80 +30556,65 @@ XS(_wrap_DOMAttr_getValue) {
}
-XS(_wrap_DOMAttr_setValue) {
+XS(_wrap_Locator_getLineNumber) {
{
- XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::Locator *arg1 = (XERCES_CPP_NAMESPACE::Locator *) 0 ;
+ XMLSSize_t result;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMAttr_setValue(self,value);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: Locator_getLineNumber(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_setValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMAttr_setValue");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locator_getLineNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Locator const *""'");
}
-
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp1);
{
try
{
- (arg1)->setValue((XMLCh const *)arg2);
+ result = ((XERCES_CPP_NAMESPACE::Locator const *)arg1)->getLineNumber();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
-
-
-
- delete[] arg2;
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
XSRETURN(argvi);
fail:
-
- delete[] arg2;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMAttr_getOwnerElement) {
+XS(_wrap_Locator_getColumnNumber) {
{
- XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
- XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+ XERCES_CPP_NAMESPACE::Locator *arg1 = (XERCES_CPP_NAMESPACE::Locator *) 0 ;
+ XMLSSize_t result;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMAttr_getOwnerElement(self);");
+ SWIG_croak("Usage: Locator_getColumnNumber(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_getOwnerElement" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locator_getColumnNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Locator const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getOwnerElement();
+ result = ((XERCES_CPP_NAMESPACE::Locator const *)arg1)->getColumnNumber();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
+ ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
XSRETURN(argvi);
fail:
@@ -31303,31 +30624,31 @@ XS(_wrap_DOMAttr_getOwnerElement) {
}
-XS(_wrap_DOMAttr_isId) {
+XS(_wrap_delete_Attributes) {
{
- XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
- bool result;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMAttr_isId(self);");
+ SWIG_croak("Usage: delete_Attributes(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_isId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Attributes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
{
try
{
- result = (bool)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->isId();
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
XSRETURN(argvi);
fail:
@@ -31337,31 +30658,31 @@ XS(_wrap_DOMAttr_isId) {
}
-XS(_wrap_DOMAttr_getSchemaTypeInfo) {
+XS(_wrap_Attributes_getLength) {
{
- XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
- XERCES_CPP_NAMESPACE::DOMTypeInfo *result = 0 ;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ unsigned int result;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMAttr_getSchemaTypeInfo(self);");
+ SWIG_croak("Usage: Attributes_getLength(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMAttr_getSchemaTypeInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMTypeInfo *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getSchemaTypeInfo();
+ result = (unsigned int)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getLength();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0 | SWIG_SHADOW); argvi++ ;
+ ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
XSRETURN(argvi);
fail:
@@ -31371,274 +30692,286 @@ XS(_wrap_DOMAttr_getSchemaTypeInfo) {
}
-XS(_wrap_delete_DOMElement) {
+XS(_wrap_Attributes_getURI) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ unsigned int arg2 ;
+ XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMElement(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Attributes_getURI(self,index);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMElement" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attributes_getURI" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
{
try
{
- delete arg1;
-
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getURI(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
+
XSRETURN(argvi);
fail:
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_getTagName) {
+XS(_wrap_Attributes_getLocalName) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ unsigned int arg2 ;
XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMElement_getTagName(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Attributes_getLocalName(self,index);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getTagName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getLocalName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attributes_getLocalName" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getTagName();
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getLocalName(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
+
XSRETURN(argvi);
fail:
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_getAttribute) {
+XS(_wrap_Attributes_getQName) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ unsigned int arg2 ;
XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMElement_getAttribute(self,name);");
+ SWIG_croak("Usage: Attributes_getQName(self,index);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_getAttribute");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getQName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
-
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attributes_getQName" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttribute((XMLCh const *)arg2);
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getQName(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
- delete[] arg2;
-
XSRETURN(argvi);
fail:
- delete[] arg2;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_getAttributeNode) {
+XS(_wrap_Attributes_getType__SWIG_0) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ unsigned int arg2 ;
+ XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMElement_getAttributeNode(self,name);");
+ SWIG_croak("Usage: Attributes_getType(self,index);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getAttributeNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_getAttributeNode");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
-
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attributes_getType" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMAttr *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttributeNode((XMLCh const *)arg2);
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getType(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
- delete[] arg2;
XSRETURN(argvi);
fail:
- delete[] arg2;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_getElementsByTagName) {
+XS(_wrap_Attributes_getValue__SWIG_0) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ unsigned int arg2 ;
+ XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ unsigned int val2 ;
+ int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMElement_getElementsByTagName(self,name);");
+ SWIG_croak("Usage: Attributes_getValue(self,index);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getElementsByTagName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_getElementsByTagName");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
-
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
+ ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attributes_getValue" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getElementsByTagName((XMLCh const *)arg2);
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getValue(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | SWIG_SHADOW); argvi++ ;
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
- delete[] arg2;
XSRETURN(argvi);
fail:
- delete[] arg2;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_setAttribute) {
+XS(_wrap_Attributes_getIndex__SWIG_0) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ int result;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMElement_setAttribute(self,name,value);");
+ SWIG_croak("Usage: Attributes_getIndex(self,uri,localPart);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getIndex" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_setAttribute");
+ SWIG_Perl_NullRef("perl-string",2,"Attributes_getIndex");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMElement_setAttribute");
+ SWIG_Perl_NullRef("perl-string",3,"Attributes_getIndex");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
try
{
- (arg1)->setAttribute((XMLCh const *)arg2,(XMLCh const *)arg3);
+ result = (int)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getIndex((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
-
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
delete[] arg2;
@@ -31660,148 +30993,150 @@ XS(_wrap_DOMElement_setAttribute) {
}
-XS(_wrap_DOMElement_setAttributeNode) {
+XS(_wrap_Attributes_getIndex__SWIG_1) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
- XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ int result;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMElement_setAttributeNode(self,newAttr);");
+ SWIG_croak("Usage: Attributes_getIndex(self,qName);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setAttributeNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMElement_setAttributeNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp2);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->setAttributeNode(arg2);
- }
- CATCH_DOM_EXCEPTION
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getIndex" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMElement_removeAttributeNode) {
- {
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
- XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMElement_removeAttributeNode(self,oldAttr);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_removeAttributeNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMElement_removeAttributeNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr *""'");
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"Attributes_getIndex");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp2);
+
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->removeAttributeNode(arg2);
+ result = (int)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getIndex((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ delete[] arg2;
XSRETURN(argvi);
fail:
+ delete[] arg2;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_removeAttribute) {
+XS(_wrap_Attributes_getIndex) {
+ dXSARGS;
+
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMElement_removeAttribute(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_removeAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_removeAttribute");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
}
+ check_1:
- {
- try
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
{
- (arg1)->removeAttribute((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(2)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
}
+ check_2:
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getIndex__SWIG_1); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getIndex__SWIG_0); return;
+ }
}
+
+ croak("No matching function for overloaded 'Attributes_getIndex'");
+ XSRETURN(0);
}
-XS(_wrap_DOMElement_getAttributeNS) {
+XS(_wrap_Attributes_getType__SWIG_1) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -31809,40 +31144,40 @@ XS(_wrap_DOMElement_getAttributeNS) {
dXSARGS;
if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMElement_getAttributeNS(self,namespaceURI,localName);");
+ SWIG_croak("Usage: Attributes_getType(self,uri,localPart);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_getAttributeNS");
+ SWIG_Perl_NullRef("perl-string",2,"Attributes_getType");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMElement_getAttributeNS");
+ SWIG_Perl_NullRef("perl-string",3,"Attributes_getType");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getType((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -31866,69 +31201,47 @@ XS(_wrap_DOMElement_getAttributeNS) {
}
-XS(_wrap_DOMElement_setAttributeNS) {
+XS(_wrap_Attributes_getType__SWIG_2) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XMLCh *arg4 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMElement_setAttributeNS(self,namespaceURI,qualifiedName,value);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Attributes_getType(self,qName);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_setAttributeNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMElement_setAttributeNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DOMElement_setAttributeNS");
+ SWIG_Perl_NullRef("perl-string",2,"Attributes_getType");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
try
{
- (arg1)->setAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getType((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
- delete[] arg2;
-
-
- delete[] arg3;
-
- delete[] arg4;
+ delete[] arg2;
XSRETURN(argvi);
fail:
@@ -31936,61 +31249,181 @@ XS(_wrap_DOMElement_setAttributeNS) {
delete[] arg2;
-
- delete[] arg3;
-
-
- delete[] arg4;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_removeAttributeNS) {
+XS(_wrap_Attributes_getType) {
+ dXSARGS;
+
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_1:
+
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(2)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_3:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getType__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getType__SWIG_2); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getType__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'Attributes_getType'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_Attributes_getValue__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMElement_removeAttributeNS(self,namespaceURI,localName);");
+ SWIG_croak("Usage: Attributes_getValue(self,uri,localPart);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_removeAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_removeAttributeNS");
+ SWIG_Perl_NullRef("perl-string",2,"Attributes_getValue");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMElement_removeAttributeNS");
+ SWIG_Perl_NullRef("perl-string",3,"Attributes_getValue");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
try
{
- (arg1)->removeAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getValue((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
+
delete[] arg2;
@@ -32012,57 +31445,47 @@ XS(_wrap_DOMElement_removeAttributeNS) {
}
-XS(_wrap_DOMElement_getAttributeNodeNS) {
+XS(_wrap_Attributes_getValue__SWIG_2) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+ XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMElement_getAttributeNodeNS(self,namespaceURI,localName);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Attributes_getValue(self,qName);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getAttributeNodeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_getAttributeNodeNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMElement_getAttributeNodeNS");
+ SWIG_Perl_NullRef("perl-string",2,"Attributes_getValue");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMAttr *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttributeNodeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getValue((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
+ ++argvi;
- delete[] arg2;
- delete[] arg3;
+ delete[] arg2;
XSRETURN(argvi);
fail:
@@ -32070,219 +31493,270 @@ XS(_wrap_DOMElement_getAttributeNodeNS) {
delete[] arg2;
-
- delete[] arg3;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_setAttributeNodeNS) {
+XS(_wrap_Attributes_getValue) {
+ dXSARGS;
+
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
- XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMElement_setAttributeNodeNS(self,newAttr);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setAttributeNodeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMElement_setAttributeNodeNS" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp2);
- {
- try
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
{
- result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->setAttributeNodeNS(arg2);
- }
- CATCH_DOM_EXCEPTION
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 1;
+ if (_rank == _rankm) goto dispatch;
+ }
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
-
+ check_1:
- XSRETURN(argvi);
- fail:
+ if (items == 2) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+ if (items == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(1)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = SvOK(ST(2)) ? 1 : 0;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_3:
- SWIG_croak_null();
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getValue__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getValue__SWIG_2); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getValue__SWIG_1); return;
+ }
}
+
+ croak("No matching function for overloaded 'Attributes_getValue'");
+ XSRETURN(0);
}
-XS(_wrap_DOMElement_getElementsByTagNameNS) {
+XS(_wrap_delete_ContentHandler) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
+ XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMElement_getElementsByTagNameNS(self,namespaceURI,localName);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_ContentHandler(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getElementsByTagNameNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_getElementsByTagNameNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMElement_getElementsByTagNameNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContentHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
}
-
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getElementsByTagNameNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | SWIG_SHADOW); argvi++ ;
- delete[] arg2;
-
-
- delete[] arg3;
-
XSRETURN(argvi);
fail:
-
- delete[] arg2;
-
-
- delete[] arg3;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_hasAttribute) {
+XS(_wrap_ContentHandler_characters) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- bool result;
+ XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ unsigned int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMElement_hasAttribute(self,name);");
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: ContentHandler_characters(self,chars,length);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_hasAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_characters" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_hasAttribute");
+ SWIG_Perl_NullRef("perl-string",2,"ContentHandler_characters");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContentHandler_characters" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
{
try
{
- result = (bool)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->hasAttribute((XMLCh const *)arg2);
+ (arg1)->characters((XMLCh const *)arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
delete[] arg2;
+
XSRETURN(argvi);
fail:
delete[] arg2;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_hasAttributeNS) {
+XS(_wrap_ContentHandler_processingInstruction) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- bool result;
+ XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMElement_hasAttributeNS(self,namespaceURI,localName);");
+ SWIG_croak("Usage: ContentHandler_processingInstruction(self,target,data);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_hasAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_processingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_hasAttributeNS");
+ SWIG_Perl_NullRef("perl-string",2,"ContentHandler_processingInstruction");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMElement_hasAttributeNS");
+ SWIG_Perl_NullRef("perl-string",3,"ContentHandler_processingInstruction");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
try
{
- result = (bool)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->hasAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
delete[] arg2;
@@ -32304,115 +31778,91 @@ XS(_wrap_DOMElement_hasAttributeNS) {
}
-XS(_wrap_DOMElement_setIdAttribute) {
+XS(_wrap_ContentHandler_setDocumentLocator) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- bool arg3 ;
+ XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::Locator *arg2 = (XERCES_CPP_NAMESPACE::Locator *) (XERCES_CPP_NAMESPACE::Locator *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- bool val3 ;
- int ecode3 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMElement_setIdAttribute(self,name,isId);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ContentHandler_setDocumentLocator(self,locator);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setIdAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_setDocumentLocator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_setIdAttribute");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ContentHandler_setDocumentLocator" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::Locator const *const""'");
}
-
- ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMElement_setIdAttribute" "', argument " "3"" of type '" "bool""'");
- }
- arg3 = static_cast< bool >(val3);
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp2);
{
try
{
- (arg1)->setIdAttribute((XMLCh const *)arg2,arg3);
+ (arg1)->setDocumentLocator((XERCES_CPP_NAMESPACE::Locator const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- delete[] arg2;
-
-
XSRETURN(argvi);
fail:
- delete[] arg2;
-
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_setIdAttributeNS) {
+XS(_wrap_ContentHandler_startPrefixMapping) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- bool arg4 ;
+ XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- bool val4 ;
- int ecode4 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMElement_setIdAttributeNS(self,namespaceURI,localName,isId);");
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: ContentHandler_startPrefixMapping(self,prefix,uri);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setIdAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_startPrefixMapping" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMElement_setIdAttributeNS");
+ SWIG_Perl_NullRef("perl-string",2,"ContentHandler_startPrefixMapping");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMElement_setIdAttributeNS");
+ SWIG_Perl_NullRef("perl-string",3,"ContentHandler_startPrefixMapping");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
- ecode4 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMElement_setIdAttributeNS" "', argument " "4"" of type '" "bool""'");
- }
- arg4 = static_cast< bool >(val4);
{
try
{
- (arg1)->setIdAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
+ (arg1)->startPrefixMapping((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -32422,7 +31872,6 @@ XS(_wrap_DOMElement_setIdAttributeNS) {
delete[] arg3;
-
XSRETURN(argvi);
fail:
@@ -32432,122 +31881,132 @@ XS(_wrap_DOMElement_setIdAttributeNS) {
delete[] arg3;
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_setIdAttributeNode) {
+XS(_wrap_ContentHandler_endPrefixMapping) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
- bool arg3 ;
+ XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- bool val3 ;
- int ecode3 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMElement_setIdAttributeNode(self,idAttr,isId);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ContentHandler_endPrefixMapping(self,prefix);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_setIdAttributeNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_endPrefixMapping" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMElement_setIdAttributeNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMAttr const *""'");
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"ContentHandler_endPrefixMapping");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMAttr * >(argp2);
- ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMElement_setIdAttributeNode" "', argument " "3"" of type '" "bool""'");
- }
- arg3 = static_cast< bool >(val3);
+
{
try
{
- (arg1)->setIdAttributeNode((XERCES_CPP_NAMESPACE::DOMAttr const *)arg2,arg3);
+ (arg1)->endPrefixMapping((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
+ delete[] arg2;
XSRETURN(argvi);
fail:
+ delete[] arg2;
SWIG_croak_null();
}
}
-XS(_wrap_DOMElement_getSchemaTypeInfo) {
+XS(_wrap_ContentHandler_skippedEntity) {
{
- XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
- XERCES_CPP_NAMESPACE::DOMTypeInfo *result = 0 ;
+ XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMElement_getSchemaTypeInfo(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: ContentHandler_skippedEntity(self,name);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMElement_getSchemaTypeInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMElement const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_skippedEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"ContentHandler_skippedEntity");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMElement * >(argp1);
+
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMTypeInfo *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getSchemaTypeInfo();
+ (arg1)->skippedEntity((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ delete[] arg2;
XSRETURN(argvi);
fail:
+
+ delete[] arg2;
+
SWIG_croak_null();
}
}
-XS(_wrap_delete_DOMEntity) {
+XS(_wrap_delete_LexicalHandler) {
{
- XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+ XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMEntity(self);");
+ SWIG_croak("Usage: delete_LexicalHandler(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LexicalHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
{
try
{
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -32559,108 +32018,89 @@ XS(_wrap_delete_DOMEntity) {
}
-XS(_wrap_DOMEntity_getPublicId) {
+XS(_wrap_LexicalHandler_comment) {
{
- XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ unsigned int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMEntity_getPublicId(self);");
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: LexicalHandler_comment(self,chars,length);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_comment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getPublicId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMEntity_getSystemId) {
- {
- XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMEntity_getSystemId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"LexicalHandler_comment");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LexicalHandler_comment" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getSystemId();
+ (arg1)->comment((XMLCh const *)arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
+
+
+ delete[] arg2;
XSRETURN(argvi);
fail:
+
+ delete[] arg2;
+
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMEntity_getNotationName) {
+XS(_wrap_LexicalHandler_endCDATA) {
{
- XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMEntity_getNotationName(self);");
+ SWIG_croak("Usage: LexicalHandler_endCDATA(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getNotationName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_endCDATA" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getNotationName();
+ (arg1)->endCDATA();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
XSRETURN(argvi);
fail:
@@ -32670,34 +32110,30 @@ XS(_wrap_DOMEntity_getNotationName) {
}
-XS(_wrap_DOMEntity_getInputEncoding) {
+XS(_wrap_LexicalHandler_endDTD) {
{
- XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMEntity_getInputEncoding(self);");
+ SWIG_croak("Usage: LexicalHandler_endDTD(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getInputEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_endDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getInputEncoding();
+ (arg1)->endDTD();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
XSRETURN(argvi);
fail:
@@ -32707,71 +32143,79 @@ XS(_wrap_DOMEntity_getInputEncoding) {
}
-XS(_wrap_DOMEntity_getXmlEncoding) {
+XS(_wrap_LexicalHandler_endEntity) {
{
- XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMEntity_getXmlEncoding(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: LexicalHandler_endEntity(self,name);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getXmlEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_endEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"LexicalHandler_endEntity");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getXmlEncoding();
+ (arg1)->endEntity((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
+ delete[] arg2;
+
XSRETURN(argvi);
fail:
+
+ delete[] arg2;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMEntity_getXmlVersion) {
+XS(_wrap_LexicalHandler_startCDATA) {
{
- XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMEntity_getXmlVersion(self);");
+ SWIG_croak("Usage: LexicalHandler_startCDATA(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMEntity_getXmlVersion" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntity const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_startCDATA" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntity * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getXmlVersion();
+ (arg1)->startCDATA();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
XSRETURN(argvi);
fail:
@@ -32781,136 +32225,161 @@ XS(_wrap_DOMEntity_getXmlVersion) {
}
-XS(_wrap_delete_DOMDocumentType) {
+XS(_wrap_LexicalHandler_startDTD) {
{
- XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+ XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMDocumentType(self);");
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: LexicalHandler_startDTD(self,name,publicId,systemId);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMDocumentType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_startDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"LexicalHandler_startDTD");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- XSRETURN(argvi);
- fail:
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"LexicalHandler_startDTD");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocumentType_getName) {
- {
- XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocumentType_getName(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"LexicalHandler_startDTD");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
+
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getName();
+ (arg1)->startDTD((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
XSRETURN(argvi);
fail:
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMDocumentType_getEntities) {
+XS(_wrap_LexicalHandler_startEntity) {
{
- XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *result = 0 ;
+ XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocumentType_getEntities(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: LexicalHandler_startEntity(self,name);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getEntities" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_startEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"LexicalHandler_startEntity");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
+
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getEntities();
+ (arg1)->startEntity((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ delete[] arg2;
XSRETURN(argvi);
fail:
+
+ delete[] arg2;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMDocumentType_getNotations) {
+XS(_wrap_delete_DeclHandler) {
{
- XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *result = 0 ;
+ XERCES_CPP_NAMESPACE::DeclHandler *arg1 = (XERCES_CPP_NAMESPACE::DeclHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocumentType_getNotations(self);");
+ SWIG_croak("Usage: delete_DeclHandler(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getNotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeclHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DeclHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DeclHandler * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getNotations();
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | SWIG_SHADOW); argvi++ ;
+
XSRETURN(argvi);
fail:
@@ -32920,372 +32389,372 @@ XS(_wrap_DOMDocumentType_getNotations) {
}
-XS(_wrap_DOMDocumentType_getPublicId) {
+XS(_wrap_DeclHandler_attributeDecl) {
{
- XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::DeclHandler *arg1 = (XERCES_CPP_NAMESPACE::DeclHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg6 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocumentType_getPublicId(self);");
+ if ((items < 6) || (items > 6)) {
+ SWIG_croak("Usage: DeclHandler_attributeDecl(self,eName,aName,type,mode,value);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeclHandler_attributeDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DeclHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getPublicId();
- }
- CATCH_DOM_EXCEPTION
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DeclHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DeclHandler_attributeDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DeclHandler_attributeDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocumentType_getSystemId) {
- {
- XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DeclHandler_attributeDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
+ }
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocumentType_getSystemId(self);");
+
+ if (ST(4) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",5,"DeclHandler_attributeDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
+
+
+ if (ST(5) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",6,"DeclHandler_attributeDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg6 = UTF8_TRANSCODER->Perl2XMLString(ST(5));
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
+
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getSystemId();
+ (arg1)->attributeDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5,(XMLCh const *)arg6);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
- XSRETURN(argvi);
- fail:
+ delete[] arg2;
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocumentType_getInternalSubset) {
- {
- XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocumentType_getInternalSubset(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentType_getInternalSubset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getInternalSubset();
- }
- CATCH_DOM_EXCEPTION
- }
+ delete[] arg3;
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
+ delete[] arg4;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMCharacterData) {
- {
- XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
+ delete[] arg5;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMCharacterData(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMCharacterData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
+ delete[] arg6;
XSRETURN(argvi);
fail:
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+
+ delete[] arg5;
+
+
+ delete[] arg6;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMCharacterData_getData) {
+XS(_wrap_DeclHandler_internalEntityDecl) {
{
- XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::DeclHandler *arg1 = (XERCES_CPP_NAMESPACE::DeclHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMCharacterData_getData(self);");
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DeclHandler_internalEntityDecl(self,name,value);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_getData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeclHandler_internalEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DeclHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DeclHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DeclHandler_internalEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DeclHandler_internalEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMCharacterData const *)arg1)->getData();
+ (arg1)->internalEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
+ delete[] arg2;
+
+
+ delete[] arg3;
+
XSRETURN(argvi);
fail:
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMCharacterData_getLength) {
+XS(_wrap_DeclHandler_externalEntityDecl) {
{
- XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
- XMLSize_t result;
+ XERCES_CPP_NAMESPACE::DeclHandler *arg1 = (XERCES_CPP_NAMESPACE::DeclHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMCharacterData_getLength(self);");
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DeclHandler_externalEntityDecl(self,name,publicId,systemId);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::DOMCharacterData const *)arg1)->getLength();
- }
- CATCH_DOM_EXCEPTION
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeclHandler_externalEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DeclHandler *""'");
}
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DeclHandler * >(argp1);
- XSRETURN(argvi);
- fail:
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DeclHandler_externalEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMCharacterData_substringData) {
- {
- XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
- XMLSize_t arg2 ;
- XMLSize_t arg3 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- size_t val2 ;
- int ecode2 = 0 ;
- size_t val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMCharacterData_substringData(self,offset,count);");
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DeclHandler_externalEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_substringData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData const *""'");
+
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DeclHandler_externalEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
- ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMCharacterData_substringData" "', argument " "2"" of type '" "XMLSize_t""'");
- }
- arg2 = static_cast< XMLSize_t >(val2);
- ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMCharacterData_substringData" "', argument " "3"" of type '" "XMLSize_t""'");
- }
- arg3 = static_cast< XMLSize_t >(val3);
+
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMCharacterData const *)arg1)->substringData(arg2,arg3);
+ (arg1)->externalEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ delete[] arg4;
XSRETURN(argvi);
fail:
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
SWIG_croak_null();
}
}
-XS(_wrap_DOMCharacterData_appendData) {
+XS(_wrap_DefaultHandler_characters) {
{
- XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ unsigned int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMCharacterData_appendData(self,arg);");
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DefaultHandler_characters(self,chars,length);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_appendData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_characters" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMCharacterData_appendData");
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_characters");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultHandler_characters" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
{
try
{
- (arg1)->appendData((XMLCh const *)arg2);
+ (arg1)->characters((XMLCh const *)arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
delete[] arg2;
+
XSRETURN(argvi);
fail:
delete[] arg2;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMCharacterData_insertData) {
+XS(_wrap_DefaultHandler_processingInstruction) {
{
- XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
- XMLSize_t arg2 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- size_t val2 ;
- int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMCharacterData_insertData(self,offset,arg);");
+ SWIG_croak("Usage: DefaultHandler_processingInstruction(self,target,data);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_insertData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_processingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
- ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMCharacterData_insertData" "', argument " "2"" of type '" "XMLSize_t""'");
- }
- arg2 = static_cast< XMLSize_t >(val2);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_processingInstruction");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMCharacterData_insertData");
+ SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_processingInstruction");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
try
{
- (arg1)->insertData(arg2,(XMLCh const *)arg3);
+ (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
+ delete[] arg2;
+
delete[] arg3;
@@ -33293,6 +32762,8 @@ XS(_wrap_DOMCharacterData_insertData) {
fail:
+ delete[] arg2;
+
delete[] arg3;
@@ -33301,160 +32772,146 @@ XS(_wrap_DOMCharacterData_insertData) {
}
-XS(_wrap_DOMCharacterData_deleteData) {
+XS(_wrap_DefaultHandler_setDocumentLocator) {
{
- XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
- XMLSize_t arg2 ;
- XMLSize_t arg3 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::Locator *arg2 = (XERCES_CPP_NAMESPACE::Locator *) (XERCES_CPP_NAMESPACE::Locator *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- size_t val2 ;
- int ecode2 = 0 ;
- size_t val3 ;
- int ecode3 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMCharacterData_deleteData(self,offset,count);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DefaultHandler_setDocumentLocator(self,locator);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_deleteData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_setDocumentLocator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
- ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMCharacterData_deleteData" "', argument " "2"" of type '" "XMLSize_t""'");
- }
- arg2 = static_cast< XMLSize_t >(val2);
- ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMCharacterData_deleteData" "', argument " "3"" of type '" "XMLSize_t""'");
- }
- arg3 = static_cast< XMLSize_t >(val3);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultHandler_setDocumentLocator" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::Locator const *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp2);
{
try
{
- (arg1)->deleteData(arg2,arg3);
+ (arg1)->setDocumentLocator((XERCES_CPP_NAMESPACE::Locator const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
-
XSRETURN(argvi);
fail:
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMCharacterData_replaceData) {
+XS(_wrap_DefaultHandler_startPrefixMapping) {
{
- XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
- XMLSize_t arg2 ;
- XMLSize_t arg3 ;
- XMLCh *arg4 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- size_t val2 ;
- int ecode2 = 0 ;
- size_t val3 ;
- int ecode3 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMCharacterData_replaceData(self,offset,count,arg);");
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DefaultHandler_startPrefixMapping(self,prefix,uri);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_replaceData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_startPrefixMapping" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
- ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMCharacterData_replaceData" "', argument " "2"" of type '" "XMLSize_t""'");
- }
- arg2 = static_cast< XMLSize_t >(val2);
- ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMCharacterData_replaceData" "', argument " "3"" of type '" "XMLSize_t""'");
- }
- arg3 = static_cast< XMLSize_t >(val3);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DOMCharacterData_replaceData");
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_startPrefixMapping");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_startPrefixMapping");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
try
{
- (arg1)->replaceData(arg2,arg3,(XMLCh const *)arg4);
+ (arg1)->startPrefixMapping((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
+ delete[] arg2;
- delete[] arg4;
+ delete[] arg3;
XSRETURN(argvi);
fail:
+ delete[] arg2;
- delete[] arg4;
+ delete[] arg3;
SWIG_croak_null();
}
}
-XS(_wrap_DOMCharacterData_setData) {
+XS(_wrap_DefaultHandler_endPrefixMapping) {
{
- XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMCharacterData_setData(self,data);");
+ SWIG_croak("Usage: DefaultHandler_endPrefixMapping(self,prefix);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMCharacterData_setData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCharacterData *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_endPrefixMapping" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCharacterData * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMCharacterData_setData");
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_endPrefixMapping");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
try
{
- (arg1)->setData((XMLCh const *)arg2);
+ (arg1)->endPrefixMapping((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -33472,107 +32929,136 @@ XS(_wrap_DOMCharacterData_setData) {
}
-XS(_wrap_delete_DOMComment) {
+XS(_wrap_DefaultHandler_skippedEntity) {
{
- XERCES_CPP_NAMESPACE::DOMComment *arg1 = (XERCES_CPP_NAMESPACE::DOMComment *) 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMComment(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DefaultHandler_skippedEntity(self,name);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMComment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMComment *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_skippedEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_skippedEntity");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMComment * >(argp1);
+
{
try
{
- delete arg1;
-
+ (arg1)->skippedEntity((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
+
+ delete[] arg2;
+
XSRETURN(argvi);
fail:
+
+ delete[] arg2;
+
SWIG_croak_null();
}
}
-XS(_wrap_delete_DOMText) {
+XS(_wrap_DefaultHandler_error) {
{
- XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMText(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DefaultHandler_error(self,exc);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_error" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultHandler_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultHandler_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
{
try
{
- delete arg1;
-
+ (arg1)->error((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
+
XSRETURN(argvi);
fail:
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMText_splitText) {
+XS(_wrap_DefaultHandler_fatalError) {
{
- XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
- XMLSize_t arg2 ;
- XERCES_CPP_NAMESPACE::DOMText *result = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- size_t val2 ;
- int ecode2 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMText_splitText(self,offset);");
+ SWIG_croak("Usage: DefaultHandler_fatalError(self,exc);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMText_splitText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_fatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
- ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMText_splitText" "', argument " "2"" of type '" "XMLSize_t""'");
- }
- arg2 = static_cast< XMLSize_t >(val2);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultHandler_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultHandler_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMText *)(arg1)->splitText(arg2);
+ (arg1)->fatalError((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | SWIG_SHADOW); argvi++ ;
+
XSRETURN(argvi);
@@ -33584,68 +33070,76 @@ XS(_wrap_DOMText_splitText) {
}
-XS(_wrap_DOMText_getIsElementContentWhitespace) {
+XS(_wrap_DefaultHandler_warning) {
{
- XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
- bool result;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMText_getIsElementContentWhitespace(self);");
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: DefaultHandler_warning(self,exc);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMText_getIsElementContentWhitespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_warning" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultHandler_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultHandler_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
{
try
{
- result = (bool)((XERCES_CPP_NAMESPACE::DOMText const *)arg1)->getIsElementContentWhitespace();
+ (arg1)->warning((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+
XSRETURN(argvi);
fail:
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMText_getWholeText) {
+XS(_wrap_DefaultHandler_resetErrors) {
{
- XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMText_getWholeText(self);");
+ SWIG_croak("Usage: DefaultHandler_resetErrors(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMText_getWholeText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_resetErrors" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMText const *)arg1)->getWholeText();
+ (arg1)->resetErrors();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
XSRETURN(argvi);
fail:
@@ -33655,227 +33149,186 @@ XS(_wrap_DOMText_getWholeText) {
}
-XS(_wrap_DOMText_replaceWholeText) {
+XS(_wrap_DefaultHandler_unparsedEntityDecl) {
{
- XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMText *result = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMText_replaceWholeText(self,content);");
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: DefaultHandler_unparsedEntityDecl(self,name,publicId,systemId,notationName);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMText_replaceWholeText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_unparsedEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMText_replaceWholeText");
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_unparsedEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_unparsedEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DefaultHandler_unparsedEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
+ }
+
+
+ if (ST(4) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",5,"DefaultHandler_unparsedEntityDecl");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMText *)(arg1)->replaceWholeText((XMLCh const *)arg2);
+ (arg1)->unparsedEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | SWIG_SHADOW); argvi++ ;
+
delete[] arg2;
- XSRETURN(argvi);
- fail:
+ delete[] arg3;
- delete[] arg2;
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMText_isIgnorableWhitespace) {
- {
- XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
+ delete[] arg4;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMText_isIgnorableWhitespace(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMText_isIgnorableWhitespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMText const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMText * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMText const *)arg1)->isIgnorableWhitespace();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
+ delete[] arg5;
XSRETURN(argvi);
fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMCDATASection) {
- {
- XERCES_CPP_NAMESPACE::DOMCDATASection *arg1 = (XERCES_CPP_NAMESPACE::DOMCDATASection *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMCDATASection(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMCDATASection" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMCDATASection *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMCDATASection * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
+ delete[] arg2;
- XSRETURN(argvi);
- fail:
+ delete[] arg3;
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMNodeList) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeList *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeList *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMNodeList(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNodeList" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeList *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeList * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
+ delete[] arg4;
- XSRETURN(argvi);
- fail:
+ delete[] arg5;
SWIG_croak_null();
}
}
-XS(_wrap_DOMNodeList_item) {
+XS(_wrap_DefaultHandler_comment) {
{
- XERCES_CPP_NAMESPACE::DOMNodeList *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeList *) 0 ;
- XMLSize_t arg2 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ unsigned int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
- size_t val2 ;
- int ecode2 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNodeList_item(self,index);");
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DefaultHandler_comment(self,chars,length);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeList_item" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeList const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_comment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeList * >(argp1);
- ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMNodeList_item" "', argument " "2"" of type '" "XMLSize_t""'");
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_comment");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+ ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultHandler_comment" "', argument " "3"" of type '" "unsigned int""'");
}
- arg2 = static_cast< XMLSize_t >(val2);
+ arg3 = static_cast< unsigned int >(val3);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNodeList const *)arg1)->item(arg2);
+ (arg1)->comment((XMLCh const *)arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+
+
+ delete[] arg2;
XSRETURN(argvi);
fail:
+ delete[] arg2;
+
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNodeList_getLength) {
+XS(_wrap_DefaultHandler_endCDATA) {
{
- XERCES_CPP_NAMESPACE::DOMNodeList *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeList *) 0 ;
- XMLSize_t result;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNodeList_getLength(self);");
+ SWIG_croak("Usage: DefaultHandler_endCDATA(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeList_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeList const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_endCDATA" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeList * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
{
try
{
- result = ((XERCES_CPP_NAMESPACE::DOMNodeList const *)arg1)->getLength();
+ (arg1)->endCDATA();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+
XSRETURN(argvi);
fail:
@@ -33885,29 +33338,28 @@ XS(_wrap_DOMNodeList_getLength) {
}
-XS(_wrap_delete_DOMNamedNodeMap) {
+XS(_wrap_DefaultHandler_endDTD) {
{
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMNamedNodeMap(self);");
+ SWIG_croak("Usage: DefaultHandler_endDTD(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNamedNodeMap" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_endDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
{
try
{
- delete arg1;
-
+ (arg1)->endDTD();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -33919,213 +33371,203 @@ XS(_wrap_delete_DOMNamedNodeMap) {
}
-XS(_wrap_DOMNamedNodeMap_setNamedItem) {
+XS(_wrap_DefaultHandler_endEntity) {
{
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNamedNodeMap_setNamedItem(self,arg);");
+ SWIG_croak("Usage: DefaultHandler_endEntity(self,name);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_setNamedItem" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_endEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNamedNodeMap_setNamedItem" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_endEntity");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
+
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->setNamedItem(arg2);
+ (arg1)->endEntity((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg2;
+
XSRETURN(argvi);
fail:
+ delete[] arg2;
+
SWIG_croak_null();
}
}
-XS(_wrap_DOMNamedNodeMap_item) {
+XS(_wrap_DefaultHandler_startCDATA) {
{
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
- XMLSize_t arg2 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- size_t val2 ;
- int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNamedNodeMap_item(self,index);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: DefaultHandler_startCDATA(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_item" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_startCDATA" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
- ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMNamedNodeMap_item" "', argument " "2"" of type '" "XMLSize_t""'");
- }
- arg2 = static_cast< XMLSize_t >(val2);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->item(arg2);
+ (arg1)->startCDATA();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
fail:
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMNamedNodeMap_getNamedItem) {
+XS(_wrap_DefaultHandler_startDTD) {
{
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNamedNodeMap_getNamedItem(self,name);");
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: DefaultHandler_startDTD(self,name,publicId,systemId);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_getNamedItem" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_startDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNamedNodeMap_getNamedItem");
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_startDTD");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_startDTD");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DefaultHandler_startDTD");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->getNamedItem((XMLCh const *)arg2);
+ (arg1)->startDTD((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
delete[] arg2;
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
XSRETURN(argvi);
fail:
delete[] arg2;
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNamedNodeMap_getLength) {
- {
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
- XMLSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNamedNodeMap_getLength(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->getLength();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
+ delete[] arg3;
- XSRETURN(argvi);
- fail:
+
+ delete[] arg4;
SWIG_croak_null();
}
}
-XS(_wrap_DOMNamedNodeMap_removeNamedItem) {
+XS(_wrap_DefaultHandler_startEntity) {
{
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNamedNodeMap_removeNamedItem(self,name);");
+ SWIG_croak("Usage: DefaultHandler_startEntity(self,name);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_removeNamedItem" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_startEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNamedNodeMap_removeNamedItem");
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_startEntity");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->removeNamedItem((XMLCh const *)arg2);
+ (arg1)->startEntity((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
delete[] arg2;
@@ -34141,676 +33583,238 @@ XS(_wrap_DOMNamedNodeMap_removeNamedItem) {
}
-XS(_wrap_DOMNamedNodeMap_getNamedItemNS) {
+XS(_wrap_DefaultHandler_attributeDecl) {
{
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg6 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMNamedNodeMap_getNamedItemNS(self,namespaceURI,localName);");
+ if ((items < 6) || (items > 6)) {
+ SWIG_croak("Usage: DefaultHandler_attributeDecl(self,eName,aName,type,mode,value);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_getNamedItemNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_attributeDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNamedNodeMap_getNamedItemNS");
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_attributeDecl");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMNamedNodeMap_getNamedItemNS");
+ SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_attributeDecl");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->getNamedItemNS((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
- delete[] arg2;
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DefaultHandler_attributeDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
+ }
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNamedNodeMap_setNamedItemNS) {
- {
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNamedNodeMap_setNamedItemNS(self,arg);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_setNamedItemNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNamedNodeMap_setNamedItemNS" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->setNamedItemNS(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNamedNodeMap_removeNamedItemNS) {
- {
- XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMNamedNodeMap_removeNamedItemNS(self,namespaceURI,localName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNamedNodeMap_removeNamedItemNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNamedNodeMap * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMNamedNodeMap_removeNamedItemNS");
+ if (ST(4) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",5,"DefaultHandler_attributeDecl");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMNamedNodeMap_removeNamedItemNS");
+ if (ST(5) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",6,"DefaultHandler_attributeDecl");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg6 = UTF8_TRANSCODER->Perl2XMLString(ST(5));
}
{
try
{
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->removeNamedItemNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+ (arg1)->attributeDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5,(XMLCh const *)arg6);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
delete[] arg2;
delete[] arg3;
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMDocumentFragment) {
- {
- XERCES_CPP_NAMESPACE::DOMDocumentFragment *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentFragment *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMDocumentFragment(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMDocumentFragment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentFragment *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentFragment * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMEntityReference) {
- {
- XERCES_CPP_NAMESPACE::DOMEntityReference *arg1 = (XERCES_CPP_NAMESPACE::DOMEntityReference *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMEntityReference(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMEntityReference" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMEntityReference *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMEntityReference * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
+ delete[] arg4;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMNotation) {
- {
- XERCES_CPP_NAMESPACE::DOMNotation *arg1 = (XERCES_CPP_NAMESPACE::DOMNotation *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
+ delete[] arg5;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMNotation(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNotation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNotation *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNotation * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
+ delete[] arg6;
XSRETURN(argvi);
fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNotation_getPublicId) {
- {
- XERCES_CPP_NAMESPACE::DOMNotation *arg1 = (XERCES_CPP_NAMESPACE::DOMNotation *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNotation_getPublicId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNotation_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNotation const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNotation * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNotation const *)arg1)->getPublicId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNotation_getSystemId) {
- {
- XERCES_CPP_NAMESPACE::DOMNotation *arg1 = (XERCES_CPP_NAMESPACE::DOMNotation *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
+ delete[] arg2;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNotation_getSystemId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNotation_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNotation const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNotation * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNotation const *)arg1)->getSystemId();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
+ delete[] arg3;
- XSRETURN(argvi);
- fail:
+ delete[] arg4;
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMProcessingInstruction) {
- {
- XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMProcessingInstruction(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMProcessingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMProcessingInstruction *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMProcessingInstruction * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
+ delete[] arg5;
- XSRETURN(argvi);
- fail:
+ delete[] arg6;
SWIG_croak_null();
}
}
-XS(_wrap_DOMProcessingInstruction_getTarget) {
+XS(_wrap_DefaultHandler_internalEntityDecl) {
{
- XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) 0 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMProcessingInstruction_getTarget(self);");
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: DefaultHandler_internalEntityDecl(self,name,value);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMProcessingInstruction_getTarget" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMProcessingInstruction * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *)arg1)->getTarget();
- }
- CATCH_DOM_EXCEPTION
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_internalEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMProcessingInstruction_getData) {
- {
- XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMProcessingInstruction_getData(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMProcessingInstruction_getData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMProcessingInstruction * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *)arg1)->getData();
- }
- CATCH_DOM_EXCEPTION
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_internalEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMProcessingInstruction_setData) {
- {
- XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMProcessingInstruction_setData(self,data);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMProcessingInstruction_setData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMProcessingInstruction *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMProcessingInstruction * >(argp1);
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMProcessingInstruction_setData");
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_internalEntityDecl");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
try
{
- (arg1)->setData((XMLCh const *)arg2);
+ (arg1)->internalEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
delete[] arg2;
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMTypeInfo) {
- {
- XERCES_CPP_NAMESPACE::DOMTypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMTypeInfo *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMTypeInfo(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMTypeInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTypeInfo *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTypeInfo * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTypeInfo_getTypeName) {
- {
- XERCES_CPP_NAMESPACE::DOMTypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMTypeInfo *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTypeInfo_getTypeName(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTypeInfo_getTypeName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTypeInfo const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTypeInfo * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMTypeInfo const *)arg1)->getTypeName();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
+ delete[] arg3;
XSRETURN(argvi);
fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTypeInfo_getTypeNamespace) {
- {
- XERCES_CPP_NAMESPACE::DOMTypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMTypeInfo *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTypeInfo_getTypeNamespace(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTypeInfo_getTypeNamespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTypeInfo const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTypeInfo * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMTypeInfo const *)arg1)->getTypeNamespace();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
+ delete[] arg2;
- XSRETURN(argvi);
- fail:
+ delete[] arg3;
SWIG_croak_null();
}
}
-XS(_wrap_DOMTypeInfo_isDerivedFrom) {
+XS(_wrap_DefaultHandler_externalEntityDecl) {
{
- XERCES_CPP_NAMESPACE::DOMTypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMTypeInfo *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- unsigned long arg4 ;
- bool result;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- unsigned long val4 ;
- int ecode4 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMTypeInfo_isDerivedFrom(self,typeNamespaceArg,typeNameArg,derivationMethod);");
+ SWIG_croak("Usage: DefaultHandler_externalEntityDecl(self,name,publicId,systemId);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTypeInfo_isDerivedFrom" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTypeInfo const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_externalEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTypeInfo * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMTypeInfo_isDerivedFrom");
+ SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_externalEntityDecl");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMTypeInfo_isDerivedFrom");
+ SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_externalEntityDecl");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+
+ if (ST(3) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",4,"DefaultHandler_externalEntityDecl");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg4 = UTF8_TRANSCODER->Perl2XMLString(ST(3));
}
- ecode4 = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMTypeInfo_isDerivedFrom" "', argument " "4"" of type '" "unsigned long""'");
- }
- arg4 = static_cast< unsigned long >(val4);
{
try
{
- result = (bool)((XERCES_CPP_NAMESPACE::DOMTypeInfo const *)arg1)->isDerivedFrom((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
+ (arg1)->externalEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
+
delete[] arg2;
@@ -34819,6 +33823,8 @@ XS(_wrap_DOMTypeInfo_isDerivedFrom) {
delete[] arg3;
+ delete[] arg4;
+
XSRETURN(argvi);
fail:
@@ -34829,161 +33835,123 @@ XS(_wrap_DOMTypeInfo_isDerivedFrom) {
delete[] arg3;
+ delete[] arg4;
+
SWIG_croak_null();
}
}
-XS(_wrap_delete_DOMPSVITypeInfo) {
+XS(_wrap_new_DefaultHandler) {
{
- XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *result = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMPSVITypeInfo(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMPSVITypeInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *""'");
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_DefaultHandler();");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMPSVITypeInfo * >(argp1);
{
try
{
- delete arg1;
-
+ result = (XERCES_CPP_NAMESPACE::DefaultHandler *)new XERCES_CPP_NAMESPACE::DefaultHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
-
-
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
fail:
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMPSVITypeInfo_getStringProperty) {
+XS(_wrap_delete_DefaultHandler) {
{
- XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *) 0 ;
- XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty arg2 ;
- XMLCh *result = 0 ;
+ XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMPSVITypeInfo_getStringProperty(self,prop);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_DefaultHandler(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMPSVITypeInfo_getStringProperty" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMPSVITypeInfo * >(argp1);
- ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMPSVITypeInfo_getStringProperty" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty""'");
- }
- arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty >(val2);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
{
try
{
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMPSVITypeInfo const *)arg1)->getStringProperty(arg2);
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
XSRETURN(argvi);
fail:
-
SWIG_croak_null();
}
}
-XS(_wrap_DOMPSVITypeInfo_getNumericProperty) {
+XS(_wrap_new_XMLPScanToken__SWIG_0) {
{
- XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *arg1 = (XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *) 0 ;
- XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty arg2 ;
- int result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ XERCES_CPP_NAMESPACE::XMLPScanToken *result = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMPSVITypeInfo_getNumericProperty(self,prop);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMPSVITypeInfo_getNumericProperty" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo const *""'");
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_XMLPScanToken();");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMPSVITypeInfo * >(argp1);
- ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMPSVITypeInfo_getNumericProperty" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty""'");
- }
- arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVIProperty >(val2);
{
try
{
- result = (int)((XERCES_CPP_NAMESPACE::DOMPSVITypeInfo const *)arg1)->getNumericProperty(arg2);
+ result = (XERCES_CPP_NAMESPACE::XMLPScanToken *)new XERCES_CPP_NAMESPACE::XMLPScanToken();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-
-
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
fail:
-
-
SWIG_croak_null();
}
}
-XS(_wrap_delete_DOMXPathEvaluator) {
+XS(_wrap_new_XMLPScanToken__SWIG_1) {
{
- XERCES_CPP_NAMESPACE::DOMXPathEvaluator *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathEvaluator *) 0 ;
- void *argp1 = 0 ;
+ XERCES_CPP_NAMESPACE::XMLPScanToken *arg1 = 0 ;
+ XERCES_CPP_NAMESPACE::XMLPScanToken *result = 0 ;
+ void *argp1 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMXPathEvaluator(self);");
+ SWIG_croak("Usage: new_XMLPScanToken(toCopy);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathEvaluator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathEvaluator *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLPScanToken" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken const &""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathEvaluator * >(argp1);
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLPScanToken" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken const &""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp1);
{
try
{
- delete arg1;
-
+ result = (XERCES_CPP_NAMESPACE::XMLPScanToken *)new XERCES_CPP_NAMESPACE::XMLPScanToken((XERCES_CPP_NAMESPACE::XMLPScanToken const &)*arg1);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
-
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
fail:
@@ -34993,314 +33961,9 @@ XS(_wrap_delete_DOMXPathEvaluator) {
}
-XS(_wrap_DOMXPathEvaluator_createExpression) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathEvaluator *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathEvaluator *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMXPathNSResolver *arg3 = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *) 0 ;
- XERCES_CPP_NAMESPACE::DOMXPathExpression *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMXPathEvaluator_createExpression(self,expression,resolver);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathEvaluator_createExpression" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathEvaluator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathEvaluator * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMXPathEvaluator_createExpression");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMXPathEvaluator_createExpression" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *""'");
- }
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNSResolver * >(argp3);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMXPathExpression *)(arg1)->createExpression((XMLCh const *)arg2,(XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathExpression, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathEvaluator_createNSResolver) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathEvaluator *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathEvaluator *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMXPathNSResolver *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMXPathEvaluator_createNSResolver(self,nodeResolver);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathEvaluator_createNSResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathEvaluator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathEvaluator * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMXPathEvaluator_createNSResolver" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *)(arg1)->createNSResolver(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0 | SWIG_SHADOW); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathEvaluator_evaluate) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathEvaluator *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathEvaluator *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg3 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMXPathNSResolver *arg4 = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *) 0 ;
- unsigned short arg5 ;
- void *arg6 = (void *) 0 ;
- void *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- unsigned short val5 ;
- int ecode5 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 6) || (items > 6)) {
- SWIG_croak("Usage: DOMXPathEvaluator_evaluate(self,expression,contextNode,resolver,type,result);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathEvaluator_evaluate" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathEvaluator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathEvaluator * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMXPathEvaluator_evaluate");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMXPathEvaluator_evaluate" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp3);
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMXPathEvaluator_evaluate" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *""'");
- }
- arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNSResolver * >(argp4);
- ecode5 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
- if (!SWIG_IsOK(ecode5)) {
- SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DOMXPathEvaluator_evaluate" "', argument " "5"" of type '" "unsigned short""'");
- }
- arg5 = static_cast< unsigned short >(val5);
- {
- arg6 = (void*) ST(5);
- }
- {
- try
- {
- result = (void *)(arg1)->evaluate((XMLCh const *)arg2,arg3,(XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *)arg4,arg5,arg6);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
-
-
- delete[] arg2;
-
-
-
-
-
- delete[] arg6;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
-
-
-
- delete[] arg6;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_DOMXPathException__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathException *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 0) || (items > 0)) {
- SWIG_croak("Usage: new_DOMXPathException();");
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMXPathException *)new XERCES_CPP_NAMESPACE::DOMXPathException();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_DOMXPathException__SWIG_1) {
- {
- short arg1 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMXPathException *result = 0 ;
- short val1 ;
- int ecode1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: new_DOMXPathException(code,message);");
- }
- ecode1 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMXPathException" "', argument " "1"" of type '" "short""'");
- }
- arg1 = static_cast< short >(val1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"new_DOMXPathException");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMXPathException *)new XERCES_CPP_NAMESPACE::DOMXPathException(arg1,(XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_DOMXPathException__SWIG_2) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = 0 ;
- XERCES_CPP_NAMESPACE::DOMXPathException *result = 0 ;
- void *argp1 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_DOMXPathException(other);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DOMXPathException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException const &""'");
- }
- if (!argp1) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DOMXPathException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException const &""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMXPathException *)new XERCES_CPP_NAMESPACE::DOMXPathException((XERCES_CPP_NAMESPACE::DOMXPathException const &)*arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_DOMXPathException) {
- dXSARGS;
-
+XS(_wrap_new_XMLPScanToken) {
+ dXSARGS;
+
{
unsigned long _index = 0;
SWIG_TypeRank _rank = 0;
@@ -35319,7 +33982,7 @@ XS(_wrap_new_DOMXPathException) {
int _v = 0;
{
void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0);
+ int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0);
_v = SWIG_CheckState(res);
}
if (!_v) goto check_2;
@@ -35333,23298 +33996,147 @@ XS(_wrap_new_DOMXPathException) {
}
check_2:
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 3;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_3:
-
dispatch:
switch(_index) {
case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMXPathException__SWIG_0); return;
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XMLPScanToken__SWIG_0); return;
case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMXPathException__SWIG_2); return;
- case 3:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMXPathException__SWIG_1); return;
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XMLPScanToken__SWIG_1); return;
}
}
- croak("No matching function for overloaded 'new_DOMXPathException'");
+ croak("No matching function for overloaded 'new_XMLPScanToken'");
XSRETURN(0);
}
-XS(_wrap_delete_DOMXPathException) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathException *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMXPathException(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathException_code_set) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathException *) 0 ;
- XERCES_CPP_NAMESPACE::DOMXPathException::ExceptionCode arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMXPathException_code_set(self,code);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathException_code_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
- ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMXPathException_code_set" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException::ExceptionCode""'");
- }
- arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMXPathException::ExceptionCode >(val2);
- if (arg1) (arg1)->code = arg2;
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathException_code_get) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathException *) 0 ;
- XERCES_CPP_NAMESPACE::DOMXPathException::ExceptionCode result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMXPathException_code_get(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathException_code_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
- result = (XERCES_CPP_NAMESPACE::DOMXPathException::ExceptionCode) ((arg1)->code);
- ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathException_msg_set) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathException *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMXPathException_msg_set(self,msg);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathException_msg_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMXPathException_msg_set");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- if (arg1) (arg1)->msg = (XMLCh const *)arg2;
-
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathException_msg_get) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathException *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathException *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMXPathException_msg_get(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathException_msg_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathException * >(argp1);
- result = (XMLCh *) ((arg1)->msg);
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMXPathExpression) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathExpression *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathExpression *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMXPathExpression(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathExpression, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathExpression" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathExpression *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathExpression * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathExpression_evaluate) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathExpression *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathExpression *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- unsigned short arg3 ;
- void *arg4 = (void *) 0 ;
- void *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- unsigned short val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMXPathExpression_evaluate(self,contextNode,type,result);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathExpression, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathExpression_evaluate" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathExpression const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathExpression * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMXPathExpression_evaluate" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- ecode3 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMXPathExpression_evaluate" "', argument " "3"" of type '" "unsigned short""'");
- }
- arg3 = static_cast< unsigned short >(val3);
- {
- arg4 = (void*) ST(3);
- }
- {
- try
- {
- result = (void *)((XERCES_CPP_NAMESPACE::DOMXPathExpression const *)arg1)->evaluate(arg2,arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
-
-
-
-
- delete[] arg4;
-
- XSRETURN(argvi);
- fail:
-
-
-
-
- delete[] arg4;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMXPathNamespace) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathNamespace *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathNamespace *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMXPathNamespace(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNamespace, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathNamespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNamespace *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNamespace * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathNamespace_getOwnerElement) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathNamespace *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathNamespace *) 0 ;
- XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMXPathNamespace_getOwnerElement(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNamespace, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathNamespace_getOwnerElement" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNamespace const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNamespace * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMXPathNamespace const *)arg1)->getOwnerElement();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMXPathNSResolver) {
+XS(_wrap_delete_XMLPScanToken) {
{
- XERCES_CPP_NAMESPACE::DOMXPathNSResolver *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLPScanToken *arg1 = (XERCES_CPP_NAMESPACE::XMLPScanToken *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMXPathNSResolver(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathNSResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNSResolver *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNSResolver * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathNSResolver_lookupNamespaceURI) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathNSResolver *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMXPathNSResolver_lookupNamespaceURI(self,prefix);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathNSResolver_lookupNamespaceURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNSResolver * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMXPathNSResolver_lookupNamespaceURI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *)arg1)->lookupNamespaceURI((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathNSResolver_lookupPrefix) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathNSResolver *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathNSResolver *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMXPathNSResolver_lookupPrefix(self,URI);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathNSResolver_lookupPrefix" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathNSResolver * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMXPathNSResolver_lookupPrefix");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMXPathNSResolver const *)arg1)->lookupPrefix((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMXPathResult) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMXPathResult(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMXPathResult" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathResult_getBooleanValue) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMXPathResult_getBooleanValue(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getBooleanValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getBooleanValue();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathResult_getInvalidIteratorState) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMXPathResult_getInvalidIteratorState(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getInvalidIteratorState" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getInvalidIteratorState();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathResult_getNumberValue) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
- double result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMXPathResult_getNumberValue(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getNumberValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
- {
- try
- {
- result = (double)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getNumberValue();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_double SWIG_PERL_CALL_ARGS_1(static_cast< double >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathResult_getResultType) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
- short result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMXPathResult_getResultType(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getResultType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
- {
- try
- {
- result = (short)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getResultType();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathResult_getSingleNodeValue) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMXPathResult_getSingleNodeValue(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getSingleNodeValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getSingleNodeValue();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathResult_getSnapshotLength) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
- unsigned long result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMXPathResult_getSnapshotLength(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getSnapshotLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
- {
- try
- {
- result = (unsigned long)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getSnapshotLength();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(static_cast< unsigned long >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathResult_getStringValue) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMXPathResult_getStringValue(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_getStringValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->getStringValue();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathResult_iterateNext) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMXPathResult_iterateNext(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_iterateNext" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->iterateNext();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMXPathResult_snapshotItem) {
- {
- XERCES_CPP_NAMESPACE::DOMXPathResult *arg1 = (XERCES_CPP_NAMESPACE::DOMXPathResult *) 0 ;
- unsigned long arg2 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned long val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMXPathResult_snapshotItem(self,index);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMXPathResult_snapshotItem" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMXPathResult const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMXPathResult * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMXPathResult_snapshotItem" "', argument " "2"" of type '" "unsigned long""'");
- }
- arg2 = static_cast< unsigned long >(val2);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMXPathResult const *)arg1)->snapshotItem(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMDocumentRange) {
- {
- XERCES_CPP_NAMESPACE::DOMDocumentRange *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentRange *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMDocumentRange(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentRange, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMDocumentRange" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentRange * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocumentRange_createRange) {
- {
- XERCES_CPP_NAMESPACE::DOMDocumentRange *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMRange *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocumentRange_createRange(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentRange_createRange" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentRange * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMRange *)(arg1)->createRange();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMDocumentTraversal) {
- {
- XERCES_CPP_NAMESPACE::DOMDocumentTraversal *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentTraversal *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMDocumentTraversal(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMDocumentTraversal" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentTraversal *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentTraversal * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocumentTraversal_createNodeIterator) {
- {
- XERCES_CPP_NAMESPACE::DOMDocumentTraversal *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentTraversal *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- unsigned long arg3 ;
- XERCES_CPP_NAMESPACE::DOMNodeFilter *arg4 = (XERCES_CPP_NAMESPACE::DOMNodeFilter *) 0 ;
- bool arg5 ;
- XERCES_CPP_NAMESPACE::DOMNodeIterator *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- unsigned long val3 ;
- int ecode3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- bool val5 ;
- int ecode5 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 5) || (items > 5)) {
- SWIG_croak("Usage: DOMDocumentTraversal_createNodeIterator(self,root,whatToShow,filter,entityReferenceExpansion);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentTraversal_createNodeIterator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentTraversal *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentTraversal * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMDocumentTraversal_createNodeIterator" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- ecode3 = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMDocumentTraversal_createNodeIterator" "', argument " "3"" of type '" "unsigned long""'");
- }
- arg3 = static_cast< unsigned long >(val3);
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMDocumentTraversal_createNodeIterator" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeFilter *""'");
- }
- arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeFilter * >(argp4);
- ecode5 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
- if (!SWIG_IsOK(ecode5)) {
- SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DOMDocumentTraversal_createNodeIterator" "', argument " "5"" of type '" "bool""'");
- }
- arg5 = static_cast< bool >(val5);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNodeIterator *)(arg1)->createNodeIterator(arg2,arg3,arg4,arg5);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | SWIG_SHADOW); argvi++ ;
-
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocumentTraversal_createTreeWalker) {
- {
- XERCES_CPP_NAMESPACE::DOMDocumentTraversal *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentTraversal *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- unsigned long arg3 ;
- XERCES_CPP_NAMESPACE::DOMNodeFilter *arg4 = (XERCES_CPP_NAMESPACE::DOMNodeFilter *) 0 ;
- bool arg5 ;
- XERCES_CPP_NAMESPACE::DOMTreeWalker *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- unsigned long val3 ;
- int ecode3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- bool val5 ;
- int ecode5 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 5) || (items > 5)) {
- SWIG_croak("Usage: DOMDocumentTraversal_createTreeWalker(self,root,whatToShow,filter,entityReferenceExpansion);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocumentTraversal_createTreeWalker" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentTraversal *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentTraversal * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMDocumentTraversal_createTreeWalker" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- ecode3 = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMDocumentTraversal_createTreeWalker" "', argument " "3"" of type '" "unsigned long""'");
- }
- arg3 = static_cast< unsigned long >(val3);
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMDocumentTraversal_createTreeWalker" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeFilter *""'");
- }
- arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeFilter * >(argp4);
- ecode5 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
- if (!SWIG_IsOK(ecode5)) {
- SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DOMDocumentTraversal_createTreeWalker" "', argument " "5"" of type '" "bool""'");
- }
- arg5 = static_cast< bool >(val5);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMTreeWalker *)(arg1)->createTreeWalker(arg2,arg3,arg4,arg5);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | SWIG_SHADOW); argvi++ ;
-
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMNodeIterator) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMNodeIterator(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNodeIterator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNodeIterator_getRoot) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNodeIterator_getRoot(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_getRoot" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->getRoot();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNodeIterator_getWhatToShow) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
- unsigned long result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNodeIterator_getWhatToShow(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_getWhatToShow" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
- {
- try
- {
- result = (unsigned long)(arg1)->getWhatToShow();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(static_cast< unsigned long >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNodeIterator_getFilter) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNodeFilter *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNodeIterator_getFilter(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_getFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNodeFilter *)(arg1)->getFilter();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNodeIterator_getExpandEntityReferences) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNodeIterator_getExpandEntityReferences(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_getExpandEntityReferences" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
- {
- try
- {
- result = (bool)(arg1)->getExpandEntityReferences();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNodeIterator_nextNode) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNodeIterator_nextNode(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_nextNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->nextNode();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNodeIterator_previousNode) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNodeIterator_previousNode(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_previousNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->previousNode();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNodeIterator_detach) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNodeIterator_detach(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_detach" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
- {
- try
- {
- (arg1)->detach();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNodeIterator_release) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeIterator *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeIterator *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMNodeIterator_release(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeIterator_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeIterator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeIterator * >(argp1);
- {
- try
- {
- (arg1)->release();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMNodeFilter) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeFilter *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeFilter *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMNodeFilter(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMNodeFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeFilter *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeFilter * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMNodeFilter_acceptNode) {
- {
- XERCES_CPP_NAMESPACE::DOMNodeFilter *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeFilter *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- short result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMNodeFilter_acceptNode(self,node);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMNodeFilter_acceptNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMNodeFilter const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNodeFilter * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMNodeFilter_acceptNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- result = (short)((XERCES_CPP_NAMESPACE::DOMNodeFilter const *)arg1)->acceptNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMRange) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMRange(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMRange" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_getStartContainer) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_getStartContainer(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getStartContainer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getStartContainer();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_getStartOffset) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XMLSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_getStartOffset(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getStartOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getStartOffset();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_getEndContainer) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_getEndContainer(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getEndContainer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getEndContainer();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_getEndOffset) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XMLSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_getEndOffset(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getEndOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getEndOffset();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_getCollapsed) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_getCollapsed(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getCollapsed" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getCollapsed();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_getCommonAncestorContainer) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_getCommonAncestorContainer(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_getCommonAncestorContainer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->getCommonAncestorContainer();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_setStart) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLSize_t arg3 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- size_t val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMRange_setStart(self,refNode,offset);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setStart" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setStart" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMRange_setStart" "', argument " "3"" of type '" "XMLSize_t""'");
- }
- arg3 = static_cast< XMLSize_t >(val3);
- {
- try
- {
- (arg1)->setStart((XERCES_CPP_NAMESPACE::DOMNode const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_setEnd) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLSize_t arg3 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- size_t val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMRange_setEnd(self,refNode,offset);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setEnd" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setEnd" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMRange_setEnd" "', argument " "3"" of type '" "XMLSize_t""'");
- }
- arg3 = static_cast< XMLSize_t >(val3);
- {
- try
- {
- (arg1)->setEnd((XERCES_CPP_NAMESPACE::DOMNode const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_setStartBefore) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMRange_setStartBefore(self,refNode);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setStartBefore" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setStartBefore" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- (arg1)->setStartBefore((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_setStartAfter) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMRange_setStartAfter(self,refNode);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setStartAfter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setStartAfter" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- (arg1)->setStartAfter((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_setEndBefore) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMRange_setEndBefore(self,refNode);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setEndBefore" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setEndBefore" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- (arg1)->setEndBefore((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_setEndAfter) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMRange_setEndAfter(self,refNode);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_setEndAfter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_setEndAfter" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- (arg1)->setEndAfter((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_collapse) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMRange_collapse(self,toStart);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_collapse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMRange_collapse" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->collapse(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_selectNode) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMRange_selectNode(self,refNode);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_selectNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_selectNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- (arg1)->selectNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_selectNodeContents) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMRange_selectNodeContents(self,refNode);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_selectNodeContents" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_selectNodeContents" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- (arg1)->selectNodeContents((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_compareBoundaryPoints) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMRange::CompareHow arg2 ;
- XERCES_CPP_NAMESPACE::DOMRange *arg3 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- short result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMRange_compareBoundaryPoints(self,how,sourceRange);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_compareBoundaryPoints" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMRange_compareBoundaryPoints" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMRange::CompareHow""'");
- }
- arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMRange::CompareHow >(val2);
- res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMRange_compareBoundaryPoints" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
- }
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp3);
- {
- try
- {
- result = (short)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->compareBoundaryPoints(arg2,(XERCES_CPP_NAMESPACE::DOMRange const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_deleteContents) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_deleteContents(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_deleteContents" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- (arg1)->deleteContents();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_extractContents) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocumentFragment *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_extractContents(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_extractContents" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocumentFragment *)(arg1)->extractContents();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_cloneContents) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocumentFragment *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_cloneContents(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_cloneContents" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocumentFragment *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->cloneContents();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_insertNode) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMRange_insertNode(self,newNode);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_insertNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_insertNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- (arg1)->insertNode(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_surroundContents) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMRange_surroundContents(self,newParent);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_surroundContents" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMRange_surroundContents" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- (arg1)->surroundContents(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_cloneRange) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XERCES_CPP_NAMESPACE::DOMRange *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_cloneRange(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_cloneRange" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMRange *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->cloneRange();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_toString) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_toString(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_toString" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMRange const *)arg1)->toString();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_detach) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_detach(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_detach" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- (arg1)->detach();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRange_release) {
- {
- XERCES_CPP_NAMESPACE::DOMRange *arg1 = (XERCES_CPP_NAMESPACE::DOMRange *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRange_release(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRange_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRange *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRange * >(argp1);
- {
- try
- {
- (arg1)->release();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_DOMRangeException) {
- {
- XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode arg1 ;
- short arg2 ;
- XERCES_CPP_NAMESPACE::MemoryManager *arg3 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
- XERCES_CPP_NAMESPACE::DOMRangeException *result = 0 ;
- int val1 ;
- int ecode1 = 0 ;
- short val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: new_DOMRangeException(code,messageCode,memoryManager);");
- }
- ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMRangeException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode""'");
- }
- arg1 = static_cast< XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode >(val1);
- ecode2 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DOMRangeException" "', argument " "2"" of type '" "short""'");
- }
- arg2 = static_cast< short >(val2);
- res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DOMRangeException" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
- }
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp3);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMRangeException *)new XERCES_CPP_NAMESPACE::DOMRangeException(arg1,arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMRangeException) {
- {
- XERCES_CPP_NAMESPACE::DOMRangeException *arg1 = (XERCES_CPP_NAMESPACE::DOMRangeException *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMRangeException(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMRangeException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRangeException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRangeException * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRangeException_code_set) {
- {
- XERCES_CPP_NAMESPACE::DOMRangeException *arg1 = (XERCES_CPP_NAMESPACE::DOMRangeException *) 0 ;
- XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMRangeException_code_set(self,code);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRangeException_code_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRangeException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRangeException * >(argp1);
- ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMRangeException_code_set" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode""'");
- }
- arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode >(val2);
- if (arg1) (arg1)->code = arg2;
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMRangeException_code_get) {
- {
- XERCES_CPP_NAMESPACE::DOMRangeException *arg1 = (XERCES_CPP_NAMESPACE::DOMRangeException *) 0 ;
- XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMRangeException_code_get(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMRangeException_code_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMRangeException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMRangeException * >(argp1);
- result = (XERCES_CPP_NAMESPACE::DOMRangeException::RangeExceptionCode) ((arg1)->code);
- ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMTreeWalker) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMTreeWalker(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMTreeWalker" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_getRoot) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_getRoot(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_getRoot" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->getRoot();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_getWhatToShow) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- unsigned long result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_getWhatToShow(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_getWhatToShow" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (unsigned long)(arg1)->getWhatToShow();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(static_cast< unsigned long >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_getFilter) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNodeFilter *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_getFilter(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_getFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNodeFilter *)(arg1)->getFilter();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_getExpandEntityReferences) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_getExpandEntityReferences(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_getExpandEntityReferences" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (bool)(arg1)->getExpandEntityReferences();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_getCurrentNode) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_getCurrentNode(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_getCurrentNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->getCurrentNode();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_parentNode) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_parentNode(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_parentNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->parentNode();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_firstChild) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_firstChild(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_firstChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->firstChild();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_lastChild) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_lastChild(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_lastChild" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->lastChild();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_previousSibling) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_previousSibling(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_previousSibling" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->previousSibling();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_nextSibling) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_nextSibling(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_nextSibling" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->nextSibling();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_previousNode) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_previousNode(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_previousNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->previousNode();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_nextNode) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_nextNode(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_nextNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->nextNode();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_setCurrentNode) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMTreeWalker_setCurrentNode(self,currentNode);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_setCurrentNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMTreeWalker_setCurrentNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- (arg1)->setCurrentNode(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMTreeWalker_release) {
- {
- XERCES_CPP_NAMESPACE::DOMTreeWalker *arg1 = (XERCES_CPP_NAMESPACE::DOMTreeWalker *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMTreeWalker_release(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMTreeWalker_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMTreeWalker *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMTreeWalker * >(argp1);
- {
- try
- {
- (arg1)->release();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMUserDataHandler) {
- {
- XERCES_CPP_NAMESPACE::DOMUserDataHandler *arg1 = (XERCES_CPP_NAMESPACE::DOMUserDataHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMUserDataHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMUserDataHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMUserDataHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMUserDataHandler * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMUserDataHandler_handle) {
- {
- XERCES_CPP_NAMESPACE::DOMUserDataHandler *arg1 = (XERCES_CPP_NAMESPACE::DOMUserDataHandler *) 0 ;
- XERCES_CPP_NAMESPACE::DOMUserDataHandler::DOMOperationType arg2 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- void *arg4 = (void *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg5 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg6 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- void *argp6 = 0 ;
- int res6 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 6) || (items > 6)) {
- SWIG_croak("Usage: DOMUserDataHandler_handle(self,operation,key,data,src,dst);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMUserDataHandler_handle" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMUserDataHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMUserDataHandler * >(argp1);
- ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMUserDataHandler_handle" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMUserDataHandler::DOMOperationType""'");
- }
- arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMUserDataHandler::DOMOperationType >(val2);
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMUserDataHandler_handle");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- arg4 = (void*) ST(3);
- }
- res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DOMUserDataHandler_handle" "', argument " "5"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg5 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp5);
- res6 = SWIG_ConvertPtr(ST(5), &argp6,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res6)) {
- SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DOMUserDataHandler_handle" "', argument " "6"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg6 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp6);
- {
- try
- {
- (arg1)->handle(arg2,(XMLCh const *)arg3,arg4,(XERCES_CPP_NAMESPACE::DOMNode const *)arg5,(XERCES_CPP_NAMESPACE::DOMNode const *)arg6);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMConfiguration_setParameter__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *arg3 = (void *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMConfiguration_setParameter(self,name,value);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_setParameter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMConfiguration_setParameter");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- // now check the value
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMConfiguration_setParameter");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
- }
- {
- try
- {
- (arg1)->setParameter((XMLCh const *)arg2,(void const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMConfiguration_setParameter__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- bool arg3 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMConfiguration_setParameter(self,name,value);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_setParameter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMConfiguration_setParameter");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMConfiguration_setParameter" "', argument " "3"" of type '" "bool""'");
- }
- arg3 = static_cast< bool >(val3);
- {
- try
- {
- (arg1)->setParameter((XMLCh const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMConfiguration_setParameter) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *ptr = 0;
- int res = SWIG_ConvertPtr(ST(2), &ptr, 0, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMConfiguration_setParameter__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMConfiguration_setParameter__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'DOMConfiguration_setParameter'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_DOMConfiguration_getParameter) {
- {
- XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMConfiguration_getParameter(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_getParameter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMConfiguration_getParameter");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (void *)((XERCES_CPP_NAMESPACE::DOMConfiguration const *)arg1)->getParameter((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMConfiguration_canSetParameter__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *arg3 = (void *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMConfiguration_canSetParameter(self,name,value);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_canSetParameter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMConfiguration_canSetParameter");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- // now check the value
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMConfiguration_canSetParameter");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
- }
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMConfiguration const *)arg1)->canSetParameter((XMLCh const *)arg2,(void const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMConfiguration_canSetParameter__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- bool arg3 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMConfiguration_canSetParameter(self,name,value);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_canSetParameter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMConfiguration_canSetParameter");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMConfiguration_canSetParameter" "', argument " "3"" of type '" "bool""'");
- }
- arg3 = static_cast< bool >(val3);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMConfiguration const *)arg1)->canSetParameter((XMLCh const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
- delete[] arg2;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMConfiguration_canSetParameter) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *ptr = 0;
- int res = SWIG_ConvertPtr(ST(2), &ptr, 0, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMConfiguration_canSetParameter__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMConfiguration_canSetParameter__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'DOMConfiguration_canSetParameter'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_DOMConfiguration_getParameterNames) {
- {
- XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
- DOMStringList *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMConfiguration_getParameterNames(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMConfiguration_getParameterNames" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
- {
- try
- {
- result = (DOMStringList *)((XERCES_CPP_NAMESPACE::DOMConfiguration const *)arg1)->getParameterNames();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMConfiguration) {
- {
- XERCES_CPP_NAMESPACE::DOMConfiguration *arg1 = (XERCES_CPP_NAMESPACE::DOMConfiguration *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMConfiguration(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMConfiguration" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMConfiguration *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMConfiguration * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMStringList) {
- {
- XERCES_CPP_NAMESPACE::DOMStringList *arg1 = (XERCES_CPP_NAMESPACE::DOMStringList *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMStringList(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMStringList" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMStringList *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMStringList * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMStringList_item) {
- {
- XERCES_CPP_NAMESPACE::DOMStringList *arg1 = (XERCES_CPP_NAMESPACE::DOMStringList *) 0 ;
- XMLSize_t arg2 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- size_t val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMStringList_item(self,index);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMStringList_item" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMStringList const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMStringList * >(argp1);
- ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMStringList_item" "', argument " "2"" of type '" "XMLSize_t""'");
- }
- arg2 = static_cast< XMLSize_t >(val2);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMStringList const *)arg1)->item(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMStringList_getLength) {
- {
- XERCES_CPP_NAMESPACE::DOMStringList *arg1 = (XERCES_CPP_NAMESPACE::DOMStringList *) 0 ;
- XMLSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMStringList_getLength(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMStringList_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMStringList const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMStringList * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::DOMStringList const *)arg1)->getLength();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMStringList_contains) {
- {
- XERCES_CPP_NAMESPACE::DOMStringList *arg1 = (XERCES_CPP_NAMESPACE::DOMStringList *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMStringList_contains(self,XMLCh const *);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMStringList_contains" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMStringList const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMStringList * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMStringList_contains");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMStringList const *)arg1)->contains((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMStringList_release) {
- {
- XERCES_CPP_NAMESPACE::DOMStringList *arg1 = (XERCES_CPP_NAMESPACE::DOMStringList *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMStringList_release(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMStringList_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMStringList *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMStringList * >(argp1);
- {
- try
- {
- (arg1)->release();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMImplementationLS) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMImplementationLS(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMImplementationLS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationLS_createLSParser__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
- unsigned short arg2 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XERCES_CPP_NAMESPACE::MemoryManager *arg4 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
- XERCES_CPP_NAMESPACE::XMLGrammarPool *arg5 = (XERCES_CPP_NAMESPACE::XMLGrammarPool *) (XERCES_CPP_NAMESPACE::XMLGrammarPool *)0 ;
- XERCES_CPP_NAMESPACE::DOMLSParser *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned short val2 ;
- int ecode2 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- arg4 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
- if ((items < 3) || (items > 5)) {
- SWIG_croak("Usage: DOMImplementationLS_createLSParser(self,mode,schemaType,manager,gramPool);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMImplementationLS_createLSParser" "', argument " "2"" of type '" "unsigned short""'");
- }
- arg2 = static_cast< unsigned short >(val2);
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMImplementationLS_createLSParser");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- if (items > 3) {
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMImplementationLS_createLSParser" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
- }
- arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp4);
- }
- if (items > 4) {
- res5 = SWIG_ConvertPtr(ST(4), &argp5,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DOMImplementationLS_createLSParser" "', argument " "5"" of type '" "XERCES_CPP_NAMESPACE::XMLGrammarPool *const""'");
- }
- arg5 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLGrammarPool * >(argp5);
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSParser *)(arg1)->createLSParser(arg2,(XMLCh const *)arg3,arg4,arg5);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | SWIG_SHADOW); argvi++ ;
-
-
-
- delete[] arg3;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- delete[] arg3;
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationLS_createLSParser__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
- unsigned short arg2 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XERCES_CPP_NAMESPACE::MemoryManager *arg4 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
- XERCES_CPP_NAMESPACE::DOMLSParser *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned short val2 ;
- int ecode2 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- arg4 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
- if ((items < 3) || (items > 4)) {
- SWIG_croak("Usage: DOMImplementationLS_createLSParser(self,mode,schemaType,manager);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMImplementationLS_createLSParser" "', argument " "2"" of type '" "unsigned short""'");
- }
- arg2 = static_cast< unsigned short >(val2);
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMImplementationLS_createLSParser");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- if (items > 3) {
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMImplementationLS_createLSParser" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
- }
- arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp4);
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSParser *)(arg1)->createLSParser(arg2,(XMLCh const *)arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | SWIG_SHADOW); argvi++ ;
-
-
-
- delete[] arg3;
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- delete[] arg3;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationLS_createLSParser__SWIG_2) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
- unsigned short arg2 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XERCES_CPP_NAMESPACE::DOMLSParser *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned short val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMImplementationLS_createLSParser(self,mode,schemaType);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMImplementationLS_createLSParser" "', argument " "2"" of type '" "unsigned short""'");
- }
- arg2 = static_cast< unsigned short >(val2);
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMImplementationLS_createLSParser");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSParser *)(arg1)->createLSParser(arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | SWIG_SHADOW); argvi++ ;
-
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationLS_createLSParser) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if ((items >= 3) && (items <= 5)) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(2)) ? 1 : 0;
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (items > 3) {
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(3), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (items > 4) {
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(4), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- }
- }
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if ((items >= 3) && (items <= 4)) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(2)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (items > 3) {
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(3), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- }
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(2)) ? 1 : 0;
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 3;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_3:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSParser__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSParser__SWIG_1); return;
- case 3:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSParser__SWIG_2); return;
- }
- }
-
- croak("No matching function for overloaded 'DOMImplementationLS_createLSParser'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_DOMImplementationLS_createLSSerializer) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLSSerializer *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMImplementationLS_createLSSerializer(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSSerializer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSSerializer *)(arg1)->createLSSerializer();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationLS_createLSInput__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
- XERCES_CPP_NAMESPACE::MemoryManager *arg2 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
- XERCES_CPP_NAMESPACE::DOMLSInput *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- arg2 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
- if ((items < 1) || (items > 2)) {
- SWIG_croak("Usage: DOMImplementationLS_createLSInput(self,manager);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
- if (items > 1) {
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMImplementationLS_createLSInput" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp2);
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSInput *)(arg1)->createLSInput(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | SWIG_SHADOW); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationLS_createLSInput__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLSInput *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMImplementationLS_createLSInput(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSInput *)(arg1)->createLSInput();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationLS_createLSInput) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if ((items >= 1) && (items <= 2)) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (items > 1) {
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- }
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 1) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSInput__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSInput__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'DOMImplementationLS_createLSInput'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_DOMImplementationLS_createLSOutput__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
- XERCES_CPP_NAMESPACE::MemoryManager *arg2 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
- XERCES_CPP_NAMESPACE::DOMLSOutput *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- arg2 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
- if ((items < 1) || (items > 2)) {
- SWIG_croak("Usage: DOMImplementationLS_createLSOutput(self,manager);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSOutput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
- if (items > 1) {
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMImplementationLS_createLSOutput" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp2);
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSOutput *)(arg1)->createLSOutput(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | SWIG_SHADOW); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationLS_createLSOutput__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationLS *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationLS *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLSOutput *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMImplementationLS_createLSOutput(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationLS_createLSOutput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationLS *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationLS * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSOutput *)(arg1)->createLSOutput();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationLS_createLSOutput) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if ((items >= 1) && (items <= 2)) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (items > 1) {
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- }
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 1) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSOutput__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementationLS_createLSOutput__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'DOMImplementationLS_createLSOutput'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_delete_DOMImplementation) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMImplementation(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMImplementation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementation_hasFeature) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMImplementation_hasFeature(self,feature,version);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementation_hasFeature" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMImplementation_hasFeature");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMImplementation_hasFeature");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMImplementation const *)arg1)->hasFeature((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementation_createDocumentType) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XMLCh *arg4 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocumentType *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMImplementation_createDocumentType(self,qualifiedName,publicId,systemId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementation_createDocumentType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMImplementation_createDocumentType");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMImplementation_createDocumentType");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DOMImplementation_createDocumentType");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocumentType *)(arg1)->createDocumentType((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementation_createDocument__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocumentType *arg4 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMImplementation_createDocument(self,namespaceURI,qualifiedName,doctype);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementation_createDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMImplementation_createDocument");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMImplementation_createDocument");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DOMImplementation_createDocument" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::DOMDocumentType *""'");
- }
- arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocumentType * >(argp4);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->createDocument((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementation_getFeature) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- void *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMImplementation_getFeature(self,feature,version);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementation_getFeature" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMImplementation_getFeature");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMImplementation_getFeature");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (void *)((XERCES_CPP_NAMESPACE::DOMImplementation const *)arg1)->getFeature((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementation_createDocument__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementation *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementation *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMImplementation_createDocument(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementation_createDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementation *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementation * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->createDocument();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementation_createDocument) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 1) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 4) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(2)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(3), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementation_createDocument__SWIG_1); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMImplementation_createDocument__SWIG_0); return;
- }
- }
-
- croak("No matching function for overloaded 'DOMImplementation_createDocument'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_DOMImplementation_getImplementation) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementation *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 0) || (items > 0)) {
- SWIG_croak("Usage: DOMImplementation_getImplementation();");
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMImplementation *)XERCES_CPP_NAMESPACE::DOMImplementation::getImplementation();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMImplementationList) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationList *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationList *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMImplementationList(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMImplementationList" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationList *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationList * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationList_item) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationList *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationList *) 0 ;
- XMLSize_t arg2 ;
- XERCES_CPP_NAMESPACE::DOMImplementation *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- size_t val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMImplementationList_item(self,index);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationList_item" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationList const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationList * >(argp1);
- ecode2 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMImplementationList_item" "', argument " "2"" of type '" "XMLSize_t""'");
- }
- arg2 = static_cast< XMLSize_t >(val2);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMImplementation *)((XERCES_CPP_NAMESPACE::DOMImplementationList const *)arg1)->item(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | SWIG_SHADOW); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationList_getLength) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationList *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationList *) 0 ;
- XMLSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMImplementationList_getLength(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationList_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationList const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationList * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::DOMImplementationList const *)arg1)->getLength();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationList_release) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationList *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationList *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMImplementationList_release(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationList_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationList *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationList * >(argp1);
- {
- try
- {
- (arg1)->release();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMImplementationSource) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationSource *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationSource *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMImplementationSource(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMImplementationSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationSource *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationSource * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationSource_getDOMImplementation) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationSource *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationSource *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMImplementation *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMImplementationSource_getDOMImplementation(self,features);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationSource_getDOMImplementation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationSource const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationSource * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMImplementationSource_getDOMImplementation");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMImplementation *)((XERCES_CPP_NAMESPACE::DOMImplementationSource const *)arg1)->getDOMImplementation((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationSource_getDOMImplementationList) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationSource *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationSource *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMImplementationList *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMImplementationSource_getDOMImplementationList(self,features);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationSource_getDOMImplementationList" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationSource const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationSource * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMImplementationSource_getDOMImplementationList");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMImplementationList *)((XERCES_CPP_NAMESPACE::DOMImplementationSource const *)arg1)->getDOMImplementationList((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationRegistry_getDOMImplementation) {
- {
- XMLCh *arg1 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMImplementation *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMImplementationRegistry_getDOMImplementation(features);");
- }
-
- if (ST(0) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",1,"DOMImplementationRegistry_getDOMImplementation");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMImplementation *)XERCES_CPP_NAMESPACE::DOMImplementationRegistry::getDOMImplementation((uint16_t const *)arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | SWIG_SHADOW); argvi++ ;
-
- delete[] arg1;
-
- XSRETURN(argvi);
- fail:
-
- delete[] arg1;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationRegistry_getDOMImplementationList) {
- {
- XMLCh *arg1 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMImplementationList *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMImplementationRegistry_getDOMImplementationList(features);");
- }
-
- if (ST(0) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",1,"DOMImplementationRegistry_getDOMImplementationList");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMImplementationList *)XERCES_CPP_NAMESPACE::DOMImplementationRegistry::getDOMImplementationList((uint16_t const *)arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0 | SWIG_SHADOW); argvi++ ;
-
- delete[] arg1;
-
- XSRETURN(argvi);
- fail:
-
- delete[] arg1;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMImplementationRegistry_addSource) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationSource *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationSource *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMImplementationRegistry_addSource(source);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMImplementationRegistry_addSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationSource *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationSource * >(argp1);
- {
- try
- {
- XERCES_CPP_NAMESPACE::DOMImplementationRegistry::addSource(arg1);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMImplementationRegistry) {
- {
- XERCES_CPP_NAMESPACE::DOMImplementationRegistry *arg1 = (XERCES_CPP_NAMESPACE::DOMImplementationRegistry *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMImplementationRegistry(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMImplementationRegistry" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMImplementationRegistry *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMImplementationRegistry * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMError) {
- {
- XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMError(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMError_getSeverity) {
- {
- XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
- short result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMError_getSeverity(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getSeverity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
- {
- try
- {
- result = (short)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getSeverity();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMError_getMessage) {
- {
- XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMError_getMessage(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getMessage" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getMessage();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMError_getLocation) {
- {
- XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLocator *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMError_getLocation(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLocator *)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getLocation();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMError_getRelatedException) {
- {
- XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
- void *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMError_getRelatedException(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getRelatedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
- {
- try
- {
- result = (void *)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getRelatedException();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMError_getType) {
- {
- XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMError_getType(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getType();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMError_getRelatedData) {
- {
- XERCES_CPP_NAMESPACE::DOMError *arg1 = (XERCES_CPP_NAMESPACE::DOMError *) 0 ;
- void *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMError_getRelatedData(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMError_getRelatedData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMError const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp1);
- {
- try
- {
- result = (void *)((XERCES_CPP_NAMESPACE::DOMError const *)arg1)->getRelatedData();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMErrorHandler) {
- {
- XERCES_CPP_NAMESPACE::DOMErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::DOMErrorHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMErrorHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMErrorHandler, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMErrorHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMErrorHandler * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMErrorHandler_handleError) {
- {
- XERCES_CPP_NAMESPACE::DOMErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::DOMErrorHandler *) 0 ;
- XERCES_CPP_NAMESPACE::DOMError *arg2 = 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMErrorHandler_handleError(self,domError);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMErrorHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMErrorHandler_handleError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMErrorHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMErrorHandler * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMErrorHandler_handleError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMError const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DOMErrorHandler_handleError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMError const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMError * >(argp2);
- {
- try
- {
- result = (bool)(arg1)->handleError((XERCES_CPP_NAMESPACE::DOMError const &)*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMDocument) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMDocument(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createElement) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_createElement(self,tagName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createElement" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createElement");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMElement *)(arg1)->createElement((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createDocumentFragment) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocumentFragment *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_createDocumentFragment(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createDocumentFragment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocumentFragment *)(arg1)->createDocumentFragment();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createTextNode) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMText *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_createTextNode(self,data);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createTextNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createTextNode");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMText *)(arg1)->createTextNode((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createComment) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMComment *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_createComment(self,data);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createComment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createComment");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMComment *)(arg1)->createComment((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createCDATASection) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMCDATASection *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_createCDATASection(self,data);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createCDATASection" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createCDATASection");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMCDATASection *)(arg1)->createCDATASection((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createProcessingInstruction) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMProcessingInstruction *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMDocument_createProcessingInstruction(self,target,data);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createProcessingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createProcessingInstruction");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMDocument_createProcessingInstruction");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *)(arg1)->createProcessingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createAttribute) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_createAttribute(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createAttribute" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createAttribute");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->createAttribute((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createEntityReference) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMEntityReference *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_createEntityReference(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createEntityReference" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createEntityReference");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMEntityReference *)(arg1)->createEntityReference((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getDoctype) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocumentType *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_getDoctype(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getDoctype" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocumentType *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getDoctype();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getImplementation) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XERCES_CPP_NAMESPACE::DOMImplementation *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_getImplementation(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getImplementation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMImplementation *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getImplementation();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getDocumentElement) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_getDocumentElement(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getDocumentElement" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getDocumentElement();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getElementsByTagName) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_getElementsByTagName(self,tagname);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getElementsByTagName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_getElementsByTagName");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getElementsByTagName((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_importNode) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- bool arg3 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- bool val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMDocument_importNode(self,importedNode,deep);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_importNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMDocument_importNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMDocument_importNode" "', argument " "3"" of type '" "bool""'");
- }
- arg3 = static_cast< bool >(val3);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->importNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createElementNS__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMDocument_createElementNS(self,namespaceURI,qualifiedName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createElementNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createElementNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMDocument_createElementNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMElement *)(arg1)->createElementNS((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createAttributeNS) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMDocument_createAttributeNS(self,namespaceURI,qualifiedName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createAttributeNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createAttributeNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMDocument_createAttributeNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->createAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getElementsByTagNameNS) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMDocument_getElementsByTagNameNS(self,namespaceURI,localName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getElementsByTagNameNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_getElementsByTagNameNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMDocument_getElementsByTagNameNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getElementsByTagNameNS((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getElementById) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_getElementById(self,elementId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getElementById" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_getElementById");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getElementById((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getInputEncoding) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_getInputEncoding(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getInputEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getInputEncoding();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getXmlEncoding) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_getXmlEncoding(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getXmlEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getXmlEncoding();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getXmlStandalone) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_getXmlStandalone(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getXmlStandalone" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getXmlStandalone();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_setXmlStandalone) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_setXmlStandalone(self,standalone);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_setXmlStandalone" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMDocument_setXmlStandalone" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setXmlStandalone(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getXmlVersion) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_getXmlVersion(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getXmlVersion" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getXmlVersion();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_setXmlVersion) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_setXmlVersion(self,version);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_setXmlVersion" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_setXmlVersion");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setXmlVersion((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getDocumentURI) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_getDocumentURI(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getDocumentURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getDocumentURI();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_setDocumentURI) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_setDocumentURI(self,documentURI);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_setDocumentURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_setDocumentURI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setDocumentURI((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getStrictErrorChecking) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_getStrictErrorChecking(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getStrictErrorChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getStrictErrorChecking();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_setStrictErrorChecking) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_setStrictErrorChecking(self,strictErrorChecking);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_setStrictErrorChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMDocument_setStrictErrorChecking" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setStrictErrorChecking(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_renameNode) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XMLCh *arg4 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMDocument_renameNode(self,n,namespaceURI,qualifiedName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_renameNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMDocument_renameNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMDocument_renameNode");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DOMDocument_renameNode");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->renameNode(arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- XSRETURN(argvi);
- fail:
-
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_adoptNode) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_adoptNode(self,source);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_adoptNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMDocument_adoptNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->adoptNode(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_normalizeDocument) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_normalizeDocument(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_normalizeDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- (arg1)->normalizeDocument();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_getDOMConfig) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XERCES_CPP_NAMESPACE::DOMConfiguration *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMDocument_getDOMConfig(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_getDOMConfig" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMConfiguration *)((XERCES_CPP_NAMESPACE::DOMDocument const *)arg1)->getDOMConfig();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createEntity) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMEntity *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_createEntity(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createEntity");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMEntity *)(arg1)->createEntity((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createDocumentType__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocumentType *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_createDocumentType(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createDocumentType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createDocumentType");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocumentType *)(arg1)->createDocumentType((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createDocumentType__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XMLCh *arg4 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocumentType *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMDocument_createDocumentType(self,qName,XMLCh const *,XMLCh const *);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createDocumentType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createDocumentType");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMDocument_createDocumentType");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DOMDocument_createDocumentType");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocumentType *)(arg1)->createDocumentType((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createDocumentType) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 4) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(2)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(3)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMDocument_createDocumentType__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMDocument_createDocumentType__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'DOMDocument_createDocumentType'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_DOMDocument_createNotation) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNotation *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMDocument_createNotation(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createNotation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createNotation");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNotation *)(arg1)->createNotation((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createElementNS__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::DOMDocument *arg1 = (XERCES_CPP_NAMESPACE::DOMDocument *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- XMLSSize_t arg4 ;
- XMLSSize_t arg5 ;
- XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- size_t val4 ;
- int ecode4 = 0 ;
- size_t val5 ;
- int ecode5 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 5) || (items > 5)) {
- SWIG_croak("Usage: DOMDocument_createElementNS(self,namespaceURI,qualifiedName,lineNum,columnNum);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMDocument_createElementNS" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMDocument *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMDocument * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMDocument_createElementNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMDocument_createElementNS");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMDocument_createElementNS" "', argument " "4"" of type '" "XMLSSize_t""'");
- }
- arg4 = static_cast< XMLSSize_t >(val4);
- ecode5 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
- if (!SWIG_IsOK(ecode5)) {
- SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DOMDocument_createElementNS" "', argument " "5"" of type '" "XMLSSize_t""'");
- }
- arg5 = static_cast< XMLSSize_t >(val5);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMElement *)(arg1)->createElementNS((XMLCh const *)arg2,(XMLCh const *)arg3,arg4,arg5);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMDocument_createElementNS) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(2)) ? 1 : 0;
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 5) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(2)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(4), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMDocument_createElementNS__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMDocument_createElementNS__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'DOMDocument_createElementNS'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_delete_DOMLocator) {
- {
- XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMLocator(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLocator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLocator_getLineNumber) {
- {
- XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
- XMLSSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLocator_getLineNumber(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getLineNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getLineNumber();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLocator_getColumnNumber) {
- {
- XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
- XMLSSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLocator_getColumnNumber(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getColumnNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getColumnNumber();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLocator_getByteOffset) {
- {
- XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
- XMLSSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLocator_getByteOffset(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getByteOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getByteOffset();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLocator_getUtf16Offset) {
- {
- XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
- XMLSSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLocator_getUtf16Offset(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getUtf16Offset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getUtf16Offset();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLocator_getRelatedNode) {
- {
- XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLocator_getRelatedNode(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getRelatedNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getRelatedNode();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLocator_getURI) {
- {
- XERCES_CPP_NAMESPACE::DOMLocator *arg1 = (XERCES_CPP_NAMESPACE::DOMLocator *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLocator_getURI(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLocator_getURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLocator const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLocator * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLocator const *)arg1)->getURI();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMLSResourceResolver) {
- {
- XERCES_CPP_NAMESPACE::DOMLSResourceResolver *arg1 = (XERCES_CPP_NAMESPACE::DOMLSResourceResolver *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMLSResourceResolver(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSResourceResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSResourceResolver *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSResourceResolver * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSResourceResolver_resolveResource) {
- {
- XERCES_CPP_NAMESPACE::DOMLSResourceResolver *arg1 = (XERCES_CPP_NAMESPACE::DOMLSResourceResolver *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg6 = (XMLCh *) (XMLCh *)0 ;
- XERCES_CPP_NAMESPACE::DOMLSInput *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 6) || (items > 6)) {
- SWIG_croak("Usage: DOMLSResourceResolver_resolveResource(self,resourceType,namespaceUri,publicId,systemId,baseURI);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSResourceResolver_resolveResource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSResourceResolver *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSResourceResolver * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSResourceResolver_resolveResource");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMLSResourceResolver_resolveResource");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DOMLSResourceResolver_resolveResource");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
-
- if (ST(4) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",5,"DOMLSResourceResolver_resolveResource");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
- }
-
-
- if (ST(5) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",6,"DOMLSResourceResolver_resolveResource");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg6 = Perl2XMLString(ST(5));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSInput *)(arg1)->resolveResource((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5,(XMLCh const *)arg6);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
-
- delete[] arg6;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
-
- delete[] arg6;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMLSInput) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMLSInput(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_getStringData) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSInput_getStringData(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getStringData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getStringData();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_getByteStream) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XERCES_CPP_NAMESPACE::InputSource *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSInput_getByteStream(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::InputSource *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getByteStream();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_getEncoding) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSInput_getEncoding(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getEncoding();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_getPublicId) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSInput_getPublicId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getPublicId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_getSystemId) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSInput_getSystemId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getSystemId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_getBaseURI) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSInput_getBaseURI(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getBaseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getBaseURI();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_setStringData) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSInput_setStringData(self,data);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setStringData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSInput_setStringData");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setStringData((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_setByteStream) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XERCES_CPP_NAMESPACE::InputSource *arg2 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSInput_setByteStream(self,stream);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSInput_setByteStream" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
- {
- try
- {
- (arg1)->setByteStream(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_setEncoding) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSInput_setEncoding(self,encodingStr);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSInput_setEncoding");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setEncoding((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_setPublicId) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSInput_setPublicId(self,publicId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSInput_setPublicId");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setPublicId((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_setSystemId) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSInput_setSystemId(self,systemId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSInput_setSystemId");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setSystemId((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_setBaseURI) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSInput_setBaseURI(self,baseURI);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setBaseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSInput_setBaseURI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setBaseURI((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_setIssueFatalErrorIfNotFound) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSInput_setIssueFatalErrorIfNotFound(self,flag);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_setIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMLSInput_setIssueFatalErrorIfNotFound" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setIssueFatalErrorIfNotFound(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_getIssueFatalErrorIfNotFound) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSInput_getIssueFatalErrorIfNotFound(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_getIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg1)->getIssueFatalErrorIfNotFound();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSInput_release) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSInput_release(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSInput_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- {
- try
- {
- (arg1)->release();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_Wrapper4InputSource) {
- {
- XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) (XERCES_CPP_NAMESPACE::InputSource *)0 ;
- bool arg2 ;
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- arg2 = true;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_Wrapper4InputSource(inputSource);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wrapper4InputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource *const""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *)new XERCES_CPP_NAMESPACE::Wrapper4InputSource(arg1,arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_Wrapper4InputSource) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_Wrapper4InputSource(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Wrapper4InputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_getStringData) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4InputSource_getStringData(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getStringData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getStringData();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_getByteStream) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XERCES_CPP_NAMESPACE::InputSource *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4InputSource_getByteStream(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::InputSource *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getByteStream();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_getEncoding) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4InputSource_getEncoding(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getEncoding();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_getPublicId) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4InputSource_getPublicId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getPublicId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_getSystemId) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4InputSource_getSystemId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getSystemId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_getBaseURI) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4InputSource_getBaseURI(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getBaseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getBaseURI();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_getIssueFatalErrorIfNotFound) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4InputSource_getIssueFatalErrorIfNotFound(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_getIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::Wrapper4InputSource const *)arg1)->getIssueFatalErrorIfNotFound();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_setStringData) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Wrapper4InputSource_setStringData(self,data);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setStringData" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Wrapper4InputSource_setStringData");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setStringData((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_setByteStream) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XERCES_CPP_NAMESPACE::InputSource *arg2 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Wrapper4InputSource_setByteStream(self,stream);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wrapper4InputSource_setByteStream" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
- {
- try
- {
- (arg1)->setByteStream(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_setEncoding) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Wrapper4InputSource_setEncoding(self,encodingStr);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Wrapper4InputSource_setEncoding");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setEncoding((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_setPublicId) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Wrapper4InputSource_setPublicId(self,publicId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Wrapper4InputSource_setPublicId");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setPublicId((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_setSystemId) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Wrapper4InputSource_setSystemId(self,systemId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Wrapper4InputSource_setSystemId");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setSystemId((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_setBaseURI) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Wrapper4InputSource_setBaseURI(self,baseURI);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setBaseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Wrapper4InputSource_setBaseURI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setBaseURI((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_setIssueFatalErrorIfNotFound) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Wrapper4InputSource_setIssueFatalErrorIfNotFound(self,flag);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_setIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wrapper4InputSource_setIssueFatalErrorIfNotFound" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setIssueFatalErrorIfNotFound(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4InputSource_release) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4InputSource *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4InputSource *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4InputSource_release(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4InputSource_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4InputSource *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4InputSource * >(argp1);
- {
- try
- {
- (arg1)->release();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_Wrapper4DOMLSInput__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) (XERCES_CPP_NAMESPACE::DOMLSInput *)0 ;
- XERCES_CPP_NAMESPACE::DOMLSResourceResolver *arg2 = (XERCES_CPP_NAMESPACE::DOMLSResourceResolver *) 0 ;
- bool arg3 ;
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- arg3 = true;
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: new_Wrapper4DOMLSInput(inputSource,entityResolver);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wrapper4DOMLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *const""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Wrapper4DOMLSInput" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSResourceResolver *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSResourceResolver * >(argp2);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *)new XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput(arg1,arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_Wrapper4DOMLSInput__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSInput *) (XERCES_CPP_NAMESPACE::DOMLSInput *)0 ;
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_Wrapper4DOMLSInput(inputSource);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wrapper4DOMLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput *const""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *)new XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput(arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_Wrapper4DOMLSInput) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 1) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_Wrapper4DOMLSInput__SWIG_1); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_Wrapper4DOMLSInput__SWIG_0); return;
- }
- }
-
- croak("No matching function for overloaded 'new_Wrapper4DOMLSInput'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_delete_Wrapper4DOMLSInput) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_Wrapper4DOMLSInput(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Wrapper4DOMLSInput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4DOMLSInput_makeStream) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
- XERCES_CPP_NAMESPACE::BinInputStream *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4DOMLSInput_makeStream(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_makeStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::BinInputStream *)((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *)arg1)->makeStream();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__BinInputStream, 0 | 0); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4DOMLSInput_getEncoding) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4DOMLSInput_getEncoding(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_getEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *)arg1)->getEncoding();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4DOMLSInput_getPublicId) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4DOMLSInput_getPublicId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *)arg1)->getPublicId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4DOMLSInput_getSystemId) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4DOMLSInput_getSystemId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *)arg1)->getSystemId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput const *)arg1)->getIssueFatalErrorIfNotFound();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4DOMLSInput_setEncoding) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Wrapper4DOMLSInput_setEncoding(self,encodingStr);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_setEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Wrapper4DOMLSInput_setEncoding");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setEncoding((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4DOMLSInput_setPublicId) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Wrapper4DOMLSInput_setPublicId(self,publicId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_setPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Wrapper4DOMLSInput_setPublicId");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setPublicId((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4DOMLSInput_setSystemId) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Wrapper4DOMLSInput_setSystemId(self,systemId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_setSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Wrapper4DOMLSInput_setSystemId");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setSystemId((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound) {
- {
- XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *arg1 = (XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound(self,flag);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setIssueFatalErrorIfNotFound(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMLSParser) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMLSParser(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_getDomConfig) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- XERCES_CPP_NAMESPACE::DOMConfiguration *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSParser_getDomConfig(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getDomConfig" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMConfiguration *)(arg1)->getDomConfig();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_getAsync) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSParser_getAsync(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getAsync" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getAsync();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_getBusy) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSParser_getBusy(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getBusy" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getBusy();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_setFilter) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLSParserFilter *arg2 = (XERCES_CPP_NAMESPACE::DOMLSParserFilter *) (XERCES_CPP_NAMESPACE::DOMLSParserFilter *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSParser_setFilter(self,filter);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_setFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParserFilter, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSParser_setFilter" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParserFilter *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParserFilter * >(argp2);
- {
- try
- {
- (arg1)->setFilter(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_parse) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLSInput *arg2 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSParser_parse(self,source);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSParser_parse" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp2);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->parse((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_parseURI) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSParser_parseURI(self,uri);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_parseURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSParser_parseURI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->parseURI((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_parseWithContext) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLSInput *arg2 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg3 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- unsigned short arg4 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- unsigned short val4 ;
- int ecode4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMLSParser_parseWithContext(self,source,contextNode,action);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_parseWithContext" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSParser_parseWithContext" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp2);
- res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMLSParser_parseWithContext" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMNode *""'");
- }
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp3);
- ecode4 = SWIG_AsVal_unsigned_SS_short SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMLSParser_parseWithContext" "', argument " "4"" of type '" "unsigned short""'");
- }
- arg4 = static_cast< unsigned short >(val4);
- {
- try
- {
- (arg1)->parseWithContext((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg2,arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_abort) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSParser_abort(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_abort" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- {
- try
- {
- (arg1)->abort();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_release) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSParser_release(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- {
- try
- {
- (arg1)->release();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_resetDocumentPool) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSParser_resetDocumentPool(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_resetDocumentPool" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- {
- try
- {
- (arg1)->resetDocumentPool();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_loadGrammar__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLSInput *arg2 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- short arg3 ;
- bool arg4 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- short val3 ;
- int ecode3 = 0 ;
- bool val4 ;
- int ecode4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMLSParser_loadGrammar(self,source,grammarType,toCache);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp2);
- ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMLSParser_loadGrammar" "', argument " "3"" of type '" "short""'");
- }
- arg3 = static_cast< short >(val3);
- ecode4 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMLSParser_loadGrammar" "', argument " "4"" of type '" "bool""'");
- }
- arg4 = static_cast< bool >(val4);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg2,arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_loadGrammar__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLSInput *arg2 = (XERCES_CPP_NAMESPACE::DOMLSInput *) 0 ;
- short arg3 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- short val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMLSParser_loadGrammar(self,source,grammarType);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSInput const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSInput * >(argp2);
- ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMLSParser_loadGrammar" "', argument " "3"" of type '" "short""'");
- }
- arg3 = static_cast< short >(val3);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::DOMLSInput const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_loadGrammar__SWIG_2) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- short arg3 ;
- bool arg4 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- short val3 ;
- int ecode3 = 0 ;
- bool val4 ;
- int ecode4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DOMLSParser_loadGrammar(self,systemId,grammarType,toCache);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSParser_loadGrammar");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMLSParser_loadGrammar" "', argument " "3"" of type '" "short""'");
- }
- arg3 = static_cast< short >(val3);
- ecode4 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DOMLSParser_loadGrammar" "', argument " "4"" of type '" "bool""'");
- }
- arg4 = static_cast< bool >(val4);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_loadGrammar__SWIG_3) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- short arg3 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- short val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMLSParser_loadGrammar(self,systemId,grammarType);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSParser_loadGrammar");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DOMLSParser_loadGrammar" "', argument " "3"" of type '" "short""'");
- }
- arg3 = static_cast< short >(val3);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_loadGrammar) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- if (items == 4) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 3;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_3:
-
- if (items == 4) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_4;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_4;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_4;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_4;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 4;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_4:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMLSParser_loadGrammar__SWIG_1); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMLSParser_loadGrammar__SWIG_3); return;
- case 3:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMLSParser_loadGrammar__SWIG_0); return;
- case 4:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_DOMLSParser_loadGrammar__SWIG_2); return;
- }
- }
-
- croak("No matching function for overloaded 'DOMLSParser_loadGrammar'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_DOMLSParser_getGrammar) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSParser_getGrammar(self,nameSpaceKey);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSParser_getGrammar");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::Grammar *)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getGrammar((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_getRootGrammar) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSParser_getRootGrammar(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getRootGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::Grammar *)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getRootGrammar();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_getURIText) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- unsigned int arg2 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSParser_getURIText(self,uriId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getURIText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMLSParser_getURIText" "', argument " "2"" of type '" "unsigned int""'");
- }
- arg2 = static_cast< unsigned int >(val2);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getURIText(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_resetCachedGrammarPool) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSParser_resetCachedGrammarPool(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_resetCachedGrammarPool" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- {
- try
- {
- (arg1)->resetCachedGrammarPool();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSParser_getSrcOffset) {
- {
- XERCES_CPP_NAMESPACE::DOMLSParser *arg1 = (XERCES_CPP_NAMESPACE::DOMLSParser *) 0 ;
- unsigned int result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSParser_getSrcOffset(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSParser_getSrcOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSParser * >(argp1);
- {
- try
- {
- result = (unsigned int)((XERCES_CPP_NAMESPACE::DOMLSParser const *)arg1)->getSrcOffset();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMLSOutput) {
- {
- XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMLSOutput(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSOutput" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSOutput_getByteStream) {
- {
- XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
- XERCES_CPP_NAMESPACE::XMLFormatTarget *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSOutput_getByteStream(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_getByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::XMLFormatTarget *)((XERCES_CPP_NAMESPACE::DOMLSOutput const *)arg1)->getByteStream();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0 | 0); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSOutput_getEncoding) {
- {
- XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSOutput_getEncoding(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_getEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSOutput const *)arg1)->getEncoding();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSOutput_getSystemId) {
- {
- XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSOutput_getSystemId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSOutput const *)arg1)->getSystemId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSOutput_setByteStream) {
- {
- XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
- XERCES_CPP_NAMESPACE::XMLFormatTarget *arg2 = (XERCES_CPP_NAMESPACE::XMLFormatTarget *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSOutput_setByteStream(self,stream);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_setByteStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSOutput_setByteStream" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatTarget *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatTarget * >(argp2);
- {
- try
- {
- (arg1)->setByteStream(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSOutput_setEncoding) {
- {
- XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSOutput_setEncoding(self,encodingStr);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_setEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSOutput_setEncoding");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setEncoding((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSOutput_setSystemId) {
- {
- XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSOutput_setSystemId(self,systemId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_setSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSOutput_setSystemId");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setSystemId((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSOutput_release) {
- {
- XERCES_CPP_NAMESPACE::DOMLSOutput *arg1 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSOutput_release(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSOutput_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp1);
- {
- try
- {
- (arg1)->release();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_StdOutFormatTarget) {
- {
- XERCES_CPP_NAMESPACE::StdOutFormatTarget *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 0) || (items > 0)) {
- SWIG_croak("Usage: new_StdOutFormatTarget();");
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::StdOutFormatTarget *)new XERCES_CPP_NAMESPACE::StdOutFormatTarget();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_StdOutFormatTarget) {
- {
- XERCES_CPP_NAMESPACE::StdOutFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::StdOutFormatTarget *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_StdOutFormatTarget(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StdOutFormatTarget" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::StdOutFormatTarget *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::StdOutFormatTarget * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_StdOutFormatTarget_writeChars) {
- {
- XERCES_CPP_NAMESPACE::StdOutFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::StdOutFormatTarget *) 0 ;
- XMLByte *arg2 = (XMLByte *) (XMLByte *)0 ;
- unsigned int arg3 ;
- XERCES_CPP_NAMESPACE::XMLFormatter *arg4 = (XERCES_CPP_NAMESPACE::XMLFormatter *) (XERCES_CPP_NAMESPACE::XMLFormatter *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- unsigned int val3 ;
- int ecode3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: StdOutFormatTarget_writeChars(self,toWrite,count,formatter);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdOutFormatTarget_writeChars" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::StdOutFormatTarget *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::StdOutFormatTarget * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdOutFormatTarget_writeChars" "', argument " "2"" of type '" "XMLByte const *const""'");
- }
- arg2 = reinterpret_cast< XMLByte * >(argp2);
- ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StdOutFormatTarget_writeChars" "', argument " "3"" of type '" "unsigned int""'");
- }
- arg3 = static_cast< unsigned int >(val3);
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StdOutFormatTarget_writeChars" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *const""'");
- }
- arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp4);
- {
- try
- {
- (arg1)->writeChars((XMLByte const *)arg2,arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_StdOutFormatTarget_flush) {
- {
- XERCES_CPP_NAMESPACE::StdOutFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::StdOutFormatTarget *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: StdOutFormatTarget_flush(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdOutFormatTarget_flush" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::StdOutFormatTarget *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::StdOutFormatTarget * >(argp1);
- {
- try
- {
- (arg1)->flush();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_LocalFileFormatTarget) {
- {
- XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
- XERCES_CPP_NAMESPACE::LocalFileFormatTarget *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_LocalFileFormatTarget(XMLCh const *const);");
- }
-
- if (ST(0) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",1,"new_LocalFileFormatTarget");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg1 = Perl2XMLString(ST(0));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::LocalFileFormatTarget *)new XERCES_CPP_NAMESPACE::LocalFileFormatTarget((XMLCh const *)arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
- delete[] arg1;
-
- XSRETURN(argvi);
- fail:
-
- delete[] arg1;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_LocalFileFormatTarget) {
- {
- XERCES_CPP_NAMESPACE::LocalFileFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::LocalFileFormatTarget *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_LocalFileFormatTarget(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalFileFormatTarget" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LocalFileFormatTarget *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LocalFileFormatTarget * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_LocalFileFormatTarget_writeChars) {
- {
- XERCES_CPP_NAMESPACE::LocalFileFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::LocalFileFormatTarget *) 0 ;
- XMLByte *arg2 = (XMLByte *) (XMLByte *)0 ;
- unsigned int arg3 ;
- XERCES_CPP_NAMESPACE::XMLFormatter *arg4 = (XERCES_CPP_NAMESPACE::XMLFormatter *) (XERCES_CPP_NAMESPACE::XMLFormatter *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- unsigned int val3 ;
- int ecode3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: LocalFileFormatTarget_writeChars(self,toWrite,count,formatter);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalFileFormatTarget_writeChars" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LocalFileFormatTarget *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LocalFileFormatTarget * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalFileFormatTarget_writeChars" "', argument " "2"" of type '" "XMLByte const *const""'");
- }
- arg2 = reinterpret_cast< XMLByte * >(argp2);
- ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LocalFileFormatTarget_writeChars" "', argument " "3"" of type '" "unsigned int""'");
- }
- arg3 = static_cast< unsigned int >(val3);
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LocalFileFormatTarget_writeChars" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *const""'");
- }
- arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp4);
- {
- try
- {
- (arg1)->writeChars((XMLByte const *)arg2,arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_LocalFileFormatTarget_flush) {
- {
- XERCES_CPP_NAMESPACE::LocalFileFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::LocalFileFormatTarget *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: LocalFileFormatTarget_flush(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalFileFormatTarget_flush" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LocalFileFormatTarget *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LocalFileFormatTarget * >(argp1);
- {
- try
- {
- (arg1)->flush();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_MemBufFormatTarget__SWIG_0) {
- {
- int arg1 ;
- XERCES_CPP_NAMESPACE::MemBufFormatTarget *result = 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_MemBufFormatTarget(initCapacity);");
- }
- ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MemBufFormatTarget" "', argument " "1"" of type '" "int""'");
- }
- arg1 = static_cast< int >(val1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *)new XERCES_CPP_NAMESPACE::MemBufFormatTarget(arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_MemBufFormatTarget__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::MemBufFormatTarget *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 0) || (items > 0)) {
- SWIG_croak("Usage: new_MemBufFormatTarget();");
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *)new XERCES_CPP_NAMESPACE::MemBufFormatTarget();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_MemBufFormatTarget) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 0) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- if (items == 1) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- {
- int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_MemBufFormatTarget__SWIG_1); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_MemBufFormatTarget__SWIG_0); return;
- }
- }
-
- croak("No matching function for overloaded 'new_MemBufFormatTarget'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_delete_MemBufFormatTarget) {
- {
- XERCES_CPP_NAMESPACE::MemBufFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_MemBufFormatTarget(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MemBufFormatTarget" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufFormatTarget *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufFormatTarget * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_MemBufFormatTarget_writeChars) {
- {
- XERCES_CPP_NAMESPACE::MemBufFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *) 0 ;
- XMLByte *arg2 = (XMLByte *) (XMLByte *)0 ;
- unsigned int arg3 ;
- XERCES_CPP_NAMESPACE::XMLFormatter *arg4 = (XERCES_CPP_NAMESPACE::XMLFormatter *) (XERCES_CPP_NAMESPACE::XMLFormatter *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- unsigned int val3 ;
- int ecode3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: MemBufFormatTarget_writeChars(self,toWrite,count,formatter);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemBufFormatTarget_writeChars" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufFormatTarget *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufFormatTarget * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemBufFormatTarget_writeChars" "', argument " "2"" of type '" "XMLByte const *const""'");
- }
- arg2 = reinterpret_cast< XMLByte * >(argp2);
- ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemBufFormatTarget_writeChars" "', argument " "3"" of type '" "unsigned int""'");
- }
- arg3 = static_cast< unsigned int >(val3);
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MemBufFormatTarget_writeChars" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *const""'");
- }
- arg4 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp4);
- {
- try
- {
- (arg1)->writeChars((XMLByte const *)arg2,arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_MemBufFormatTarget_getRawBuffer) {
- {
- XERCES_CPP_NAMESPACE::MemBufFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *) 0 ;
- XMLByte *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: MemBufFormatTarget_getRawBuffer(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemBufFormatTarget_getRawBuffer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufFormatTarget const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufFormatTarget * >(argp1);
- {
- try
- {
- result = (XMLByte *)((XERCES_CPP_NAMESPACE::MemBufFormatTarget const *)arg1)->getRawBuffer();
- }
- CATCH_DOM_EXCEPTION
- }
- {
- ST(argvi) = SWIG_FromCharPtr((char*)result); argvi++ ;
- }
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_MemBufFormatTarget_getLen) {
- {
- XERCES_CPP_NAMESPACE::MemBufFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *) 0 ;
- unsigned int result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: MemBufFormatTarget_getLen(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemBufFormatTarget_getLen" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufFormatTarget const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufFormatTarget * >(argp1);
- {
- try
- {
- result = (unsigned int)((XERCES_CPP_NAMESPACE::MemBufFormatTarget const *)arg1)->getLen();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_MemBufFormatTarget_reset) {
- {
- XERCES_CPP_NAMESPACE::MemBufFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::MemBufFormatTarget *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: MemBufFormatTarget_reset(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemBufFormatTarget_reset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufFormatTarget *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufFormatTarget * >(argp1);
- {
- try
- {
- (arg1)->reset();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_DOMLSException__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::DOMLSException *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 0) || (items > 0)) {
- SWIG_croak("Usage: new_DOMLSException();");
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSException *)new XERCES_CPP_NAMESPACE::DOMLSException();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_DOMLSException__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode arg1 ;
- short arg2 ;
- XERCES_CPP_NAMESPACE::MemoryManager *arg3 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
- XERCES_CPP_NAMESPACE::DOMLSException *result = 0 ;
- int val1 ;
- int ecode1 = 0 ;
- short val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: new_DOMLSException(code,messageCode,memoryManager);");
- }
- ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOMLSException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode""'");
- }
- arg1 = static_cast< XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode >(val1);
- ecode2 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DOMLSException" "', argument " "2"" of type '" "short""'");
- }
- arg2 = static_cast< short >(val2);
- res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DOMLSException" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
- }
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp3);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSException *)new XERCES_CPP_NAMESPACE::DOMLSException(arg1,arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_DOMLSException__SWIG_2) {
- {
- XERCES_CPP_NAMESPACE::DOMLSException *arg1 = 0 ;
- XERCES_CPP_NAMESPACE::DOMLSException *result = 0 ;
- void *argp1 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_DOMLSException(other);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DOMLSException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException const &""'");
- }
- if (!argp1) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DOMLSException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException const &""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMLSException *)new XERCES_CPP_NAMESPACE::DOMLSException((XERCES_CPP_NAMESPACE::DOMLSException const &)*arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_DOMLSException) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 0) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- if (items == 1) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- {
- int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 3;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_3:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMLSException__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMLSException__SWIG_2); return;
- case 3:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_DOMLSException__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'new_DOMLSException'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_delete_DOMLSException) {
- {
- XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMLSException(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSException_getMessage) {
- {
- XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSException_getMessage(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSException_getMessage" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSException const *)arg1)->getMessage();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSException_code_set) {
- {
- XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSException_code_set(self,code);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSException_code_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
- ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOMLSException_code_set" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode""'");
- }
- arg2 = static_cast< XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode >(val2);
- if (arg1) (arg1)->code = arg2;
-
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSException_code_get) {
- {
- XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSException_code_get(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSException_code_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
- result = (XERCES_CPP_NAMESPACE::DOMLSException::LSExceptionCode) ((arg1)->code);
- ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSException_msg_set) {
- {
- XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSException_msg_set(self,msg);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSException_msg_set" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSException_msg_set");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- if (arg1) (arg1)->msg = (XMLCh const *)arg2;
-
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSException_msg_get) {
- {
- XERCES_CPP_NAMESPACE::DOMLSException *arg1 = (XERCES_CPP_NAMESPACE::DOMLSException *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSException_msg_get(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSException_msg_get" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSException * >(argp1);
- result = (XMLCh *) ((arg1)->msg);
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMLSSerializer) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMLSSerializer(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSSerializer" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSSerializer_getDomConfig) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
- XERCES_CPP_NAMESPACE::DOMConfiguration *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSSerializer_getDomConfig(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_getDomConfig" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMConfiguration *)(arg1)->getDomConfig();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSSerializer_setNewLine) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSSerializer_setNewLine(self,newLine);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_setNewLine" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DOMLSSerializer_setNewLine");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setNewLine((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSSerializer_setFilter) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
- DOMLSSerializerFilter *arg2 = (DOMLSSerializerFilter *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSSerializer_setFilter(self,filter);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_setFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSSerializer_setFilter" "', argument " "2"" of type '" "DOMLSSerializerFilter *""'");
- }
- arg2 = reinterpret_cast< DOMLSSerializerFilter * >(argp2);
- {
- try
- {
- (arg1)->setFilter(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSSerializer_getNewLine) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSSerializer_getNewLine(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_getNewLine" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMLSSerializer const *)arg1)->getNewLine();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSSerializer_write) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XERCES_CPP_NAMESPACE::DOMLSOutput *arg3 = (XERCES_CPP_NAMESPACE::DOMLSOutput *) (XERCES_CPP_NAMESPACE::DOMLSOutput *)0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMLSSerializer_write(self,nodeToWrite,destination);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_write" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSSerializer_write" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DOMLSSerializer_write" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::DOMLSOutput *const""'");
- }
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSOutput * >(argp3);
- {
- try
- {
- result = (bool)(arg1)->write((XERCES_CPP_NAMESPACE::DOMNode const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSSerializer_writeToURI) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *arg3 = (XMLCh *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DOMLSSerializer_writeToURI(self,nodeToWrite,uri);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_writeToURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSSerializer_writeToURI" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DOMLSSerializer_writeToURI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (bool)(arg1)->writeToURI((XERCES_CPP_NAMESPACE::DOMNode const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSSerializer_writeToString) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSSerializer_writeToString(self,nodeToWrite);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_writeToString" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSSerializer_writeToString" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- result = (XMLCh *)(arg1)->writeToString((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSSerializer_release) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializer *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializer *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSSerializer_release(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializer_release" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializer *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializer * >(argp1);
- {
- try
- {
- (arg1)->release();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DOMLSSerializerFilter) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DOMLSSerializerFilter(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOMLSSerializerFilter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializerFilter * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSSerializerFilter_acceptNode) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- short result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DOMLSSerializerFilter_acceptNode(self,node);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializerFilter_acceptNode" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializerFilter const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializerFilter * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOMLSSerializerFilter_acceptNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- result = (short)((XERCES_CPP_NAMESPACE::DOMLSSerializerFilter const *)arg1)->acceptNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DOMLSSerializerFilter_getWhatToShow) {
- {
- XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *arg1 = (XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *) 0 ;
- unsigned long result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DOMLSSerializerFilter_getWhatToShow(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOMLSSerializerFilter_getWhatToShow" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DOMLSSerializerFilter const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMLSSerializerFilter * >(argp1);
- {
- try
- {
- result = (unsigned long)((XERCES_CPP_NAMESPACE::DOMLSSerializerFilter const *)arg1)->getWhatToShow();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(static_cast< unsigned long >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_SAXException) {
- {
- XERCES_CPP_NAMESPACE::SAXException *arg1 = (XERCES_CPP_NAMESPACE::SAXException *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_SAXException(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SAXException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXException * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_SAXException_getMessage) {
- {
- XERCES_CPP_NAMESPACE::SAXException *arg1 = (XERCES_CPP_NAMESPACE::SAXException *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: SAXException_getMessage(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXException_getMessage" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXException * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXException const *)arg1)->getMessage();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_SAXNotSupportedException) {
- {
- XERCES_CPP_NAMESPACE::SAXException *arg1 = 0 ;
- XERCES_CPP_NAMESPACE::SAXNotSupportedException *result = 0 ;
- void *argp1 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_SAXNotSupportedException(toCopy);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException, 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SAXNotSupportedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException const &""'");
- }
- if (!argp1) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SAXNotSupportedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException const &""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXException * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::SAXNotSupportedException *)new XERCES_CPP_NAMESPACE::SAXNotSupportedException((XERCES_CPP_NAMESPACE::SAXException const &)*arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_SAXNotSupportedException) {
- {
- XERCES_CPP_NAMESPACE::SAXNotSupportedException *arg1 = (XERCES_CPP_NAMESPACE::SAXNotSupportedException *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_SAXNotSupportedException(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SAXNotSupportedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXNotSupportedException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXNotSupportedException * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_SAXNotRecognizedException) {
- {
- XERCES_CPP_NAMESPACE::SAXException *arg1 = 0 ;
- XERCES_CPP_NAMESPACE::SAXNotRecognizedException *result = 0 ;
- void *argp1 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_SAXNotRecognizedException(toCopy);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException, 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SAXNotRecognizedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException const &""'");
- }
- if (!argp1) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SAXNotRecognizedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXException const &""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXException * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::SAXNotRecognizedException *)new XERCES_CPP_NAMESPACE::SAXNotRecognizedException((XERCES_CPP_NAMESPACE::SAXException const &)*arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_SAXNotRecognizedException) {
- {
- XERCES_CPP_NAMESPACE::SAXNotRecognizedException *arg1 = (XERCES_CPP_NAMESPACE::SAXNotRecognizedException *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_SAXNotRecognizedException(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SAXNotRecognizedException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXNotRecognizedException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXNotRecognizedException * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_SAXParseException) {
- {
- XERCES_CPP_NAMESPACE::SAXParseException *arg1 = (XERCES_CPP_NAMESPACE::SAXParseException *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_SAXParseException(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SAXParseException" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_SAXParseException_getColumnNumber) {
- {
- XERCES_CPP_NAMESPACE::SAXParseException *arg1 = (XERCES_CPP_NAMESPACE::SAXParseException *) 0 ;
- XMLSSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: SAXParseException_getColumnNumber(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParseException_getColumnNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::SAXParseException const *)arg1)->getColumnNumber();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_SAXParseException_getLineNumber) {
- {
- XERCES_CPP_NAMESPACE::SAXParseException *arg1 = (XERCES_CPP_NAMESPACE::SAXParseException *) 0 ;
- XMLSSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: SAXParseException_getLineNumber(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParseException_getLineNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::SAXParseException const *)arg1)->getLineNumber();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_SAXParseException_getPublicId) {
- {
- XERCES_CPP_NAMESPACE::SAXParseException *arg1 = (XERCES_CPP_NAMESPACE::SAXParseException *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: SAXParseException_getPublicId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParseException_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXParseException const *)arg1)->getPublicId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_SAXParseException_getSystemId) {
- {
- XERCES_CPP_NAMESPACE::SAXParseException *arg1 = (XERCES_CPP_NAMESPACE::SAXParseException *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: SAXParseException_getSystemId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParseException_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXParseException const *)arg1)->getSystemId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_ErrorHandler) {
- {
- XERCES_CPP_NAMESPACE::ErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::ErrorHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_ErrorHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_ErrorHandler_warning) {
- {
- XERCES_CPP_NAMESPACE::ErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::ErrorHandler *) 0 ;
- XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: ErrorHandler_warning(self,exc);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ErrorHandler_warning" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ErrorHandler_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ErrorHandler_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
- {
- try
- {
- (arg1)->warning((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_ErrorHandler_error) {
- {
- XERCES_CPP_NAMESPACE::ErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::ErrorHandler *) 0 ;
- XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: ErrorHandler_error(self,exc);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ErrorHandler_error" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ErrorHandler_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ErrorHandler_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
- {
- try
- {
- (arg1)->error((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_ErrorHandler_fatalError) {
- {
- XERCES_CPP_NAMESPACE::ErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::ErrorHandler *) 0 ;
- XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: ErrorHandler_fatalError(self,exc);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ErrorHandler_fatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ErrorHandler_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ErrorHandler_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
- {
- try
- {
- (arg1)->fatalError((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_ErrorHandler_resetErrors) {
- {
- XERCES_CPP_NAMESPACE::ErrorHandler *arg1 = (XERCES_CPP_NAMESPACE::ErrorHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: ErrorHandler_resetErrors(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ErrorHandler_resetErrors" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp1);
- {
- try
- {
- (arg1)->resetErrors();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DTDHandler) {
- {
- XERCES_CPP_NAMESPACE::DTDHandler *arg1 = (XERCES_CPP_NAMESPACE::DTDHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DTDHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DTDHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DTDHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DTDHandler * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DTDHandler_unparsedEntityDecl) {
- {
- XERCES_CPP_NAMESPACE::DTDHandler *arg1 = (XERCES_CPP_NAMESPACE::DTDHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 5) || (items > 5)) {
- SWIG_croak("Usage: DTDHandler_unparsedEntityDecl(self,name,publicId,systemId,notationName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTDHandler_unparsedEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DTDHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DTDHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DTDHandler_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DTDHandler_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DTDHandler_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
-
- if (ST(4) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",5,"DTDHandler_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
- }
-
- {
- try
- {
- (arg1)->unparsedEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DocumentHandler) {
- {
- XERCES_CPP_NAMESPACE::DocumentHandler *arg1 = (XERCES_CPP_NAMESPACE::DocumentHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DocumentHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DocumentHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DocumentHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DocumentHandler * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DocumentHandler_characters) {
- {
- XERCES_CPP_NAMESPACE::DocumentHandler *arg1 = (XERCES_CPP_NAMESPACE::DocumentHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- unsigned int arg3 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DocumentHandler_characters(self,chars,length);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DocumentHandler_characters" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DocumentHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DocumentHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DocumentHandler_characters");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DocumentHandler_characters" "', argument " "3"" of type '" "unsigned int""'");
- }
- arg3 = static_cast< unsigned int >(val3);
- {
- try
- {
- (arg1)->characters((XMLCh const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DocumentHandler_processingInstruction) {
- {
- XERCES_CPP_NAMESPACE::DocumentHandler *arg1 = (XERCES_CPP_NAMESPACE::DocumentHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DocumentHandler_processingInstruction(self,target,data);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DocumentHandler_processingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DocumentHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DocumentHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DocumentHandler_processingInstruction");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DocumentHandler_processingInstruction");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DocumentHandler_setDocumentLocator) {
- {
- XERCES_CPP_NAMESPACE::DocumentHandler *arg1 = (XERCES_CPP_NAMESPACE::DocumentHandler *) 0 ;
- XERCES_CPP_NAMESPACE::Locator *arg2 = (XERCES_CPP_NAMESPACE::Locator *) (XERCES_CPP_NAMESPACE::Locator *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DocumentHandler_setDocumentLocator(self,locator);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DocumentHandler_setDocumentLocator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DocumentHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DocumentHandler * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DocumentHandler_setDocumentLocator" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::Locator const *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp2);
- {
- try
- {
- (arg1)->setDocumentLocator((XERCES_CPP_NAMESPACE::Locator const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_EntityResolver) {
- {
- XERCES_CPP_NAMESPACE::EntityResolver *arg1 = (XERCES_CPP_NAMESPACE::EntityResolver *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_EntityResolver(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__EntityResolver, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::EntityResolver *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::EntityResolver * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_AttributeList) {
- {
- XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_AttributeList(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AttributeList" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AttributeList_getLength) {
- {
- XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
- unsigned int result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AttributeList_getLength(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
- {
- try
- {
- result = (unsigned int)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getLength();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AttributeList_getName) {
- {
- XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
- unsigned int arg2 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AttributeList_getName(self,index);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttributeList_getName" "', argument " "2"" of type '" "unsigned int""'");
- }
- arg2 = static_cast< unsigned int >(val2);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getName(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AttributeList_getType__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
- unsigned int arg2 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AttributeList_getType(self,index);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttributeList_getType" "', argument " "2"" of type '" "unsigned int""'");
- }
- arg2 = static_cast< unsigned int >(val2);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getType(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AttributeList_getValue__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
- unsigned int arg2 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AttributeList_getValue(self,index);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttributeList_getValue" "', argument " "2"" of type '" "unsigned int""'");
- }
- arg2 = static_cast< unsigned int >(val2);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getValue(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AttributeList_getType__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AttributeList_getType(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"AttributeList_getType");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getType((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AttributeList_getType) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AttributeList_getType__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AttributeList_getType__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'AttributeList_getType'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_AttributeList_getValue__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::AttributeList *arg1 = (XERCES_CPP_NAMESPACE::AttributeList *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AttributeList_getValue(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttributeList_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AttributeList const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AttributeList * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"AttributeList_getValue");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getValue((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AttributeList_getValue) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AttributeList_getValue__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AttributeList_getValue__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'AttributeList_getValue'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_HandlerBase_characters) {
- {
- XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- unsigned int arg3 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: HandlerBase_characters(self,chars,length);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_characters" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"HandlerBase_characters");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HandlerBase_characters" "', argument " "3"" of type '" "unsigned int""'");
- }
- arg3 = static_cast< unsigned int >(val3);
- {
- try
- {
- (arg1)->characters((XMLCh const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_HandlerBase_processingInstruction) {
- {
- XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: HandlerBase_processingInstruction(self,target,data);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_processingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"HandlerBase_processingInstruction");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"HandlerBase_processingInstruction");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_HandlerBase_setDocumentLocator) {
- {
- XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
- XERCES_CPP_NAMESPACE::Locator *arg2 = (XERCES_CPP_NAMESPACE::Locator *) (XERCES_CPP_NAMESPACE::Locator *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: HandlerBase_setDocumentLocator(self,locator);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_setDocumentLocator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HandlerBase_setDocumentLocator" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::Locator const *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp2);
- {
- try
- {
- (arg1)->setDocumentLocator((XERCES_CPP_NAMESPACE::Locator const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_HandlerBase_error) {
- {
- XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
- XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: HandlerBase_error(self,exc);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_error" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HandlerBase_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HandlerBase_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
- {
- try
- {
- (arg1)->error((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_HandlerBase_fatalError) {
- {
- XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
- XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: HandlerBase_fatalError(self,exc);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_fatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HandlerBase_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HandlerBase_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
- {
- try
- {
- (arg1)->fatalError((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_HandlerBase_warning) {
- {
- XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
- XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: HandlerBase_warning(self,exc);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_warning" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HandlerBase_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HandlerBase_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
- {
- try
- {
- (arg1)->warning((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_HandlerBase_resetErrors) {
- {
- XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: HandlerBase_resetErrors(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_resetErrors" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
- {
- try
- {
- (arg1)->resetErrors();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_HandlerBase_unparsedEntityDecl) {
- {
- XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 5) || (items > 5)) {
- SWIG_croak("Usage: HandlerBase_unparsedEntityDecl(self,name,publicId,systemId,notationName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HandlerBase_unparsedEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"HandlerBase_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"HandlerBase_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"HandlerBase_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
-
- if (ST(4) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",5,"HandlerBase_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
- }
-
- {
- try
- {
- (arg1)->unparsedEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_HandlerBase) {
- {
- XERCES_CPP_NAMESPACE::HandlerBase *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 0) || (items > 0)) {
- SWIG_croak("Usage: new_HandlerBase();");
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::HandlerBase *)new XERCES_CPP_NAMESPACE::HandlerBase();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_HandlerBase) {
- {
- XERCES_CPP_NAMESPACE::HandlerBase *arg1 = (XERCES_CPP_NAMESPACE::HandlerBase *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_HandlerBase(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HandlerBase" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::HandlerBase *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::HandlerBase * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_Locator) {
- {
- XERCES_CPP_NAMESPACE::Locator *arg1 = (XERCES_CPP_NAMESPACE::Locator *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_Locator(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Locator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Locator *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Locator_getPublicId) {
- {
- XERCES_CPP_NAMESPACE::Locator *arg1 = (XERCES_CPP_NAMESPACE::Locator *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Locator_getPublicId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locator_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Locator const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Locator const *)arg1)->getPublicId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Locator_getSystemId) {
- {
- XERCES_CPP_NAMESPACE::Locator *arg1 = (XERCES_CPP_NAMESPACE::Locator *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Locator_getSystemId(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locator_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Locator const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Locator const *)arg1)->getSystemId();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Locator_getLineNumber) {
- {
- XERCES_CPP_NAMESPACE::Locator *arg1 = (XERCES_CPP_NAMESPACE::Locator *) 0 ;
- XMLSSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Locator_getLineNumber(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locator_getLineNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Locator const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::Locator const *)arg1)->getLineNumber();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Locator_getColumnNumber) {
- {
- XERCES_CPP_NAMESPACE::Locator *arg1 = (XERCES_CPP_NAMESPACE::Locator *) 0 ;
- XMLSSize_t result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Locator_getColumnNumber(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Locator_getColumnNumber" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Locator const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp1);
- {
- try
- {
- result = ((XERCES_CPP_NAMESPACE::Locator const *)arg1)->getColumnNumber();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_size_t SWIG_PERL_CALL_ARGS_1(static_cast< size_t >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_Attributes) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_Attributes(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Attributes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getLength) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- unsigned int result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: Attributes_getLength(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getLength" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
- {
- try
- {
- result = (unsigned int)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getLength();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getURI) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- unsigned int arg2 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Attributes_getURI(self,index);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getURI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attributes_getURI" "', argument " "2"" of type '" "unsigned int""'");
- }
- arg2 = static_cast< unsigned int >(val2);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getURI(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getLocalName) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- unsigned int arg2 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Attributes_getLocalName(self,index);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getLocalName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attributes_getLocalName" "', argument " "2"" of type '" "unsigned int""'");
- }
- arg2 = static_cast< unsigned int >(val2);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getLocalName(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getQName) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- unsigned int arg2 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Attributes_getQName(self,index);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getQName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attributes_getQName" "', argument " "2"" of type '" "unsigned int""'");
- }
- arg2 = static_cast< unsigned int >(val2);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getQName(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getType__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- unsigned int arg2 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Attributes_getType(self,index);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attributes_getType" "', argument " "2"" of type '" "unsigned int""'");
- }
- arg2 = static_cast< unsigned int >(val2);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getType(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getValue__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- unsigned int arg2 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Attributes_getValue(self,index);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Attributes_getValue" "', argument " "2"" of type '" "unsigned int""'");
- }
- arg2 = static_cast< unsigned int >(val2);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getValue(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getIndex__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- int result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: Attributes_getIndex(self,uri,localPart);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getIndex" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Attributes_getIndex");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"Attributes_getIndex");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (int)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getIndex((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getIndex__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- int result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Attributes_getIndex(self,qName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getIndex" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Attributes_getIndex");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (int)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getIndex((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getIndex) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(2)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getIndex__SWIG_1); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getIndex__SWIG_0); return;
- }
- }
-
- croak("No matching function for overloaded 'Attributes_getIndex'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_Attributes_getType__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: Attributes_getType(self,uri,localPart);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Attributes_getType");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"Attributes_getType");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getType((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getType__SWIG_2) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Attributes_getType(self,qName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getType" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Attributes_getType");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getType((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getType) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(2)) ? 1 : 0;
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 3;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_3:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getType__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getType__SWIG_2); return;
- case 3:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getType__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'Attributes_getType'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_Attributes_getValue__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: Attributes_getValue(self,uri,localPart);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Attributes_getValue");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"Attributes_getValue");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getValue((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getValue__SWIG_2) {
- {
- XERCES_CPP_NAMESPACE::Attributes *arg1 = (XERCES_CPP_NAMESPACE::Attributes *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: Attributes_getValue(self,qName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Attributes_getValue" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Attributes const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Attributes * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"Attributes_getValue");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getValue((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_Attributes_getValue) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(2)) ? 1 : 0;
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 3;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_3:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getValue__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getValue__SWIG_2); return;
- case 3:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Attributes_getValue__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'Attributes_getValue'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_delete_ContentHandler) {
- {
- XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_ContentHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContentHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_ContentHandler_characters) {
- {
- XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- unsigned int arg3 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: ContentHandler_characters(self,chars,length);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_characters" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"ContentHandler_characters");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContentHandler_characters" "', argument " "3"" of type '" "unsigned int""'");
- }
- arg3 = static_cast< unsigned int >(val3);
- {
- try
- {
- (arg1)->characters((XMLCh const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_ContentHandler_processingInstruction) {
- {
- XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: ContentHandler_processingInstruction(self,target,data);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_processingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"ContentHandler_processingInstruction");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"ContentHandler_processingInstruction");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_ContentHandler_setDocumentLocator) {
- {
- XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
- XERCES_CPP_NAMESPACE::Locator *arg2 = (XERCES_CPP_NAMESPACE::Locator *) (XERCES_CPP_NAMESPACE::Locator *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: ContentHandler_setDocumentLocator(self,locator);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_setDocumentLocator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ContentHandler_setDocumentLocator" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::Locator const *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp2);
- {
- try
- {
- (arg1)->setDocumentLocator((XERCES_CPP_NAMESPACE::Locator const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_ContentHandler_startPrefixMapping) {
- {
- XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: ContentHandler_startPrefixMapping(self,prefix,uri);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_startPrefixMapping" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"ContentHandler_startPrefixMapping");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"ContentHandler_startPrefixMapping");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- (arg1)->startPrefixMapping((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_ContentHandler_endPrefixMapping) {
- {
- XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: ContentHandler_endPrefixMapping(self,prefix);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_endPrefixMapping" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"ContentHandler_endPrefixMapping");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->endPrefixMapping((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_ContentHandler_skippedEntity) {
- {
- XERCES_CPP_NAMESPACE::ContentHandler *arg1 = (XERCES_CPP_NAMESPACE::ContentHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: ContentHandler_skippedEntity(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContentHandler_skippedEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"ContentHandler_skippedEntity");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->skippedEntity((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_LexicalHandler) {
- {
- XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_LexicalHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LexicalHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_LexicalHandler_comment) {
- {
- XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- unsigned int arg3 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: LexicalHandler_comment(self,chars,length);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_comment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"LexicalHandler_comment");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LexicalHandler_comment" "', argument " "3"" of type '" "unsigned int""'");
- }
- arg3 = static_cast< unsigned int >(val3);
- {
- try
- {
- (arg1)->comment((XMLCh const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_LexicalHandler_endCDATA) {
- {
- XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: LexicalHandler_endCDATA(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_endCDATA" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
- {
- try
- {
- (arg1)->endCDATA();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_LexicalHandler_endDTD) {
- {
- XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: LexicalHandler_endDTD(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_endDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
- {
- try
- {
- (arg1)->endDTD();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_LexicalHandler_endEntity) {
- {
- XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: LexicalHandler_endEntity(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_endEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"LexicalHandler_endEntity");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->endEntity((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_LexicalHandler_startCDATA) {
- {
- XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: LexicalHandler_startCDATA(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_startCDATA" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
- {
- try
- {
- (arg1)->startCDATA();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_LexicalHandler_startDTD) {
- {
- XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: LexicalHandler_startDTD(self,name,publicId,systemId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_startDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"LexicalHandler_startDTD");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"LexicalHandler_startDTD");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"LexicalHandler_startDTD");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
- {
- try
- {
- (arg1)->startDTD((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_LexicalHandler_startEntity) {
- {
- XERCES_CPP_NAMESPACE::LexicalHandler *arg1 = (XERCES_CPP_NAMESPACE::LexicalHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: LexicalHandler_startEntity(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LexicalHandler_startEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"LexicalHandler_startEntity");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->startEntity((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DeclHandler) {
- {
- XERCES_CPP_NAMESPACE::DeclHandler *arg1 = (XERCES_CPP_NAMESPACE::DeclHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DeclHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeclHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DeclHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DeclHandler * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DeclHandler_attributeDecl) {
- {
- XERCES_CPP_NAMESPACE::DeclHandler *arg1 = (XERCES_CPP_NAMESPACE::DeclHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg6 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 6) || (items > 6)) {
- SWIG_croak("Usage: DeclHandler_attributeDecl(self,eName,aName,type,mode,value);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeclHandler_attributeDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DeclHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DeclHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DeclHandler_attributeDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DeclHandler_attributeDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DeclHandler_attributeDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
-
- if (ST(4) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",5,"DeclHandler_attributeDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
- }
-
-
- if (ST(5) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",6,"DeclHandler_attributeDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg6 = Perl2XMLString(ST(5));
- }
-
- {
- try
- {
- (arg1)->attributeDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5,(XMLCh const *)arg6);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
-
- delete[] arg6;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
-
- delete[] arg6;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DeclHandler_internalEntityDecl) {
- {
- XERCES_CPP_NAMESPACE::DeclHandler *arg1 = (XERCES_CPP_NAMESPACE::DeclHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DeclHandler_internalEntityDecl(self,name,value);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeclHandler_internalEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DeclHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DeclHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DeclHandler_internalEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DeclHandler_internalEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- (arg1)->internalEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DeclHandler_externalEntityDecl) {
- {
- XERCES_CPP_NAMESPACE::DeclHandler *arg1 = (XERCES_CPP_NAMESPACE::DeclHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DeclHandler_externalEntityDecl(self,name,publicId,systemId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeclHandler_externalEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DeclHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DeclHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DeclHandler_externalEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DeclHandler_externalEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DeclHandler_externalEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
- {
- try
- {
- (arg1)->externalEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_characters) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- unsigned int arg3 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DefaultHandler_characters(self,chars,length);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_characters" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_characters");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultHandler_characters" "', argument " "3"" of type '" "unsigned int""'");
- }
- arg3 = static_cast< unsigned int >(val3);
- {
- try
- {
- (arg1)->characters((XMLCh const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_processingInstruction) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DefaultHandler_processingInstruction(self,target,data);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_processingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_processingInstruction");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_processingInstruction");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_setDocumentLocator) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XERCES_CPP_NAMESPACE::Locator *arg2 = (XERCES_CPP_NAMESPACE::Locator *) (XERCES_CPP_NAMESPACE::Locator *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DefaultHandler_setDocumentLocator(self,locator);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_setDocumentLocator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultHandler_setDocumentLocator" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::Locator const *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::Locator * >(argp2);
- {
- try
- {
- (arg1)->setDocumentLocator((XERCES_CPP_NAMESPACE::Locator const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_startPrefixMapping) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DefaultHandler_startPrefixMapping(self,prefix,uri);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_startPrefixMapping" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_startPrefixMapping");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_startPrefixMapping");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- (arg1)->startPrefixMapping((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_endPrefixMapping) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DefaultHandler_endPrefixMapping(self,prefix);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_endPrefixMapping" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_endPrefixMapping");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->endPrefixMapping((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_skippedEntity) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DefaultHandler_skippedEntity(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_skippedEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_skippedEntity");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->skippedEntity((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_error) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DefaultHandler_error(self,exc);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_error" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultHandler_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultHandler_error" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
- {
- try
- {
- (arg1)->error((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_fatalError) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DefaultHandler_fatalError(self,exc);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_fatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultHandler_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultHandler_fatalError" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
- {
- try
- {
- (arg1)->fatalError((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_warning) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XERCES_CPP_NAMESPACE::SAXParseException *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DefaultHandler_warning(self,exc);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_warning" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultHandler_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultHandler_warning" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParseException const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParseException * >(argp2);
- {
- try
- {
- (arg1)->warning((XERCES_CPP_NAMESPACE::SAXParseException const &)*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_resetErrors) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DefaultHandler_resetErrors(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_resetErrors" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
- {
- try
- {
- (arg1)->resetErrors();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_unparsedEntityDecl) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 5) || (items > 5)) {
- SWIG_croak("Usage: DefaultHandler_unparsedEntityDecl(self,name,publicId,systemId,notationName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_unparsedEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DefaultHandler_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
-
- if (ST(4) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",5,"DefaultHandler_unparsedEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
- }
-
- {
- try
- {
- (arg1)->unparsedEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_comment) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- unsigned int arg3 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val3 ;
- int ecode3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DefaultHandler_comment(self,chars,length);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_comment" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_comment");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultHandler_comment" "', argument " "3"" of type '" "unsigned int""'");
- }
- arg3 = static_cast< unsigned int >(val3);
- {
- try
- {
- (arg1)->comment((XMLCh const *)arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_endCDATA) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DefaultHandler_endCDATA(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_endCDATA" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
- {
- try
- {
- (arg1)->endCDATA();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_endDTD) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DefaultHandler_endDTD(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_endDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
- {
- try
- {
- (arg1)->endDTD();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_endEntity) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DefaultHandler_endEntity(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_endEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_endEntity");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->endEntity((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_startCDATA) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: DefaultHandler_startCDATA(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_startCDATA" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
- {
- try
- {
- (arg1)->startCDATA();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_startDTD) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DefaultHandler_startDTD(self,name,publicId,systemId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_startDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_startDTD");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_startDTD");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DefaultHandler_startDTD");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
- {
- try
- {
- (arg1)->startDTD((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_startEntity) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: DefaultHandler_startEntity(self,name);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_startEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_startEntity");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->startEntity((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_attributeDecl) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg6 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 6) || (items > 6)) {
- SWIG_croak("Usage: DefaultHandler_attributeDecl(self,eName,aName,type,mode,value);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_attributeDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_attributeDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_attributeDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DefaultHandler_attributeDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
-
- if (ST(4) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",5,"DefaultHandler_attributeDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
- }
-
-
- if (ST(5) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",6,"DefaultHandler_attributeDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg6 = Perl2XMLString(ST(5));
- }
-
- {
- try
- {
- (arg1)->attributeDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5,(XMLCh const *)arg6);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
-
- delete[] arg6;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
-
- delete[] arg5;
-
-
- delete[] arg6;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_internalEntityDecl) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: DefaultHandler_internalEntityDecl(self,name,value);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_internalEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_internalEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_internalEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- try
- {
- (arg1)->internalEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_DefaultHandler_externalEntityDecl) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg4 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: DefaultHandler_externalEntityDecl(self,name,publicId,systemId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultHandler_externalEntityDecl" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"DefaultHandler_externalEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"DefaultHandler_externalEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
-
- if (ST(3) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",4,"DefaultHandler_externalEntityDecl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg4 = Perl2XMLString(ST(3));
- }
-
- {
- try
- {
- (arg1)->externalEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- delete[] arg4;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_DefaultHandler) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 0) || (items > 0)) {
- SWIG_croak("Usage: new_DefaultHandler();");
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DefaultHandler *)new XERCES_CPP_NAMESPACE::DefaultHandler();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_DefaultHandler) {
- {
- XERCES_CPP_NAMESPACE::DefaultHandler *arg1 = (XERCES_CPP_NAMESPACE::DefaultHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_DefaultHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::DefaultHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::DefaultHandler * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_XMLPScanToken__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::XMLPScanToken *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 0) || (items > 0)) {
- SWIG_croak("Usage: new_XMLPScanToken();");
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::XMLPScanToken *)new XERCES_CPP_NAMESPACE::XMLPScanToken();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_XMLPScanToken__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::XMLPScanToken *arg1 = 0 ;
- XERCES_CPP_NAMESPACE::XMLPScanToken *result = 0 ;
- void *argp1 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_XMLPScanToken(toCopy);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XMLPScanToken" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken const &""'");
- }
- if (!argp1) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XMLPScanToken" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken const &""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::XMLPScanToken *)new XERCES_CPP_NAMESPACE::XMLPScanToken((XERCES_CPP_NAMESPACE::XMLPScanToken const &)*arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_XMLPScanToken) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 0) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- if (items == 1) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XMLPScanToken__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XMLPScanToken__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'new_XMLPScanToken'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_delete_XMLPScanToken) {
- {
- XERCES_CPP_NAMESPACE::XMLPScanToken *arg1 = (XERCES_CPP_NAMESPACE::XMLPScanToken *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_XMLPScanToken(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLPScanToken" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_PSVIHandler) {
- {
- XERCES_CPP_NAMESPACE::PSVIHandler *arg1 = (XERCES_CPP_NAMESPACE::PSVIHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_PSVIHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PSVIHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PSVIHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PSVIHandler * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_PSVIHandler_handleElementPSVI) {
- {
- XERCES_CPP_NAMESPACE::PSVIHandler *arg1 = (XERCES_CPP_NAMESPACE::PSVIHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- PSVIElement *arg4 = (PSVIElement *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: PSVIHandler_handleElementPSVI(self,localName,uri,elementInfo);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PSVIHandler_handleElementPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PSVIHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PSVIHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"PSVIHandler_handleElementPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"PSVIHandler_handleElementPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIElement, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PSVIHandler_handleElementPSVI" "', argument " "4"" of type '" "PSVIElement *""'");
- }
- arg4 = reinterpret_cast< PSVIElement * >(argp4);
- {
- try
- {
- (arg1)->handleElementPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_PSVIHandler_handlePartialElementPSVI) {
- {
- XERCES_CPP_NAMESPACE::PSVIHandler *arg1 = (XERCES_CPP_NAMESPACE::PSVIHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- PSVIElement *arg4 = (PSVIElement *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: PSVIHandler_handlePartialElementPSVI(self,localName,uri,elementInfo);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PSVIHandler_handlePartialElementPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PSVIHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PSVIHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"PSVIHandler_handlePartialElementPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"PSVIHandler_handlePartialElementPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIElement, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PSVIHandler_handlePartialElementPSVI" "', argument " "4"" of type '" "PSVIElement *""'");
- }
- arg4 = reinterpret_cast< PSVIElement * >(argp4);
- {
- try
- {
- (arg1)->handlePartialElementPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_PSVIHandler_handleAttributesPSVI) {
- {
- XERCES_CPP_NAMESPACE::PSVIHandler *arg1 = (XERCES_CPP_NAMESPACE::PSVIHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- PSVIAttributeList *arg4 = (PSVIAttributeList *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: PSVIHandler_handleAttributesPSVI(self,localName,uri,psviAttributes);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PSVIHandler_handleAttributesPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PSVIHandler *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PSVIHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"PSVIHandler_handleAttributesPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"PSVIHandler_handleAttributesPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIAttributeList, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PSVIHandler_handleAttributesPSVI" "', argument " "4"" of type '" "PSVIAttributeList *""'");
- }
- arg4 = reinterpret_cast< PSVIAttributeList * >(argp4);
- {
- try
- {
- (arg1)->handleAttributesPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_delete_AbstractDOMParser) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_AbstractDOMParser(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AbstractDOMParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_reset) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_reset(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_reset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- (arg1)->reset();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_adoptDocument) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_adoptDocument(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_adoptDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->adoptDocument();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getDocument) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getDocument(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getDocument" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::DOMDocument *)(arg1)->getDocument();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getValidator) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::XMLValidator *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getValidator(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getValidator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- {
- XERCES_CPP_NAMESPACE::XMLValidator const &_result_ref = ((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getValidator();
- result = (XERCES_CPP_NAMESPACE::XMLValidator *) &_result_ref;
- }
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getValidationScheme) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::AbstractDOMParser::ValSchemes result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getValidationScheme(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getValidationScheme" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::AbstractDOMParser::ValSchemes)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getValidationScheme();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getDoSchema) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getDoSchema(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getDoSchema" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getDoSchema();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getValidationSchemaFullChecking) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getValidationSchemaFullChecking(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getValidationSchemaFullChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getValidationSchemaFullChecking();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getIdentityConstraintChecking) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getIdentityConstraintChecking(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getIdentityConstraintChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getIdentityConstraintChecking();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getErrorCount) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- int result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getErrorCount(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getErrorCount" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (int)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getErrorCount();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getDoNamespaces) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getDoNamespaces(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getDoNamespaces" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getDoNamespaces();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getExitOnFirstFatalError) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getExitOnFirstFatalError(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getExitOnFirstFatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getExitOnFirstFatalError();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getValidationConstraintFatal) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getValidationConstraintFatal(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getValidationConstraintFatal" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getValidationConstraintFatal();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getCreateEntityReferenceNodes) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getCreateEntityReferenceNodes(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getCreateEntityReferenceNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getCreateEntityReferenceNodes();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getIncludeIgnorableWhitespace) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getIncludeIgnorableWhitespace(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getIncludeIgnorableWhitespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getIncludeIgnorableWhitespace();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getExternalSchemaLocation) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getExternalSchemaLocation(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getExternalSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getExternalSchemaLocation();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getExternalNoNamespaceSchemaLocation) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getExternalNoNamespaceSchemaLocation(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getExternalNoNamespaceSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getExternalNoNamespaceSchemaLocation();
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getSecurityManager) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- SecurityManager *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getSecurityManager(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getSecurityManager" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (SecurityManager *)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getSecurityManager();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SecurityManager, 0 | 0); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getLoadExternalDTD) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getLoadExternalDTD(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getLoadExternalDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getLoadExternalDTD();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getCreateCommentNodes) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getCreateCommentNodes(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getCreateCommentNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getCreateCommentNodes();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getCalculateSrcOfs) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getCalculateSrcOfs(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getCalculateSrcOfs" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getCalculateSrcOfs();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getStandardUriConformant) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getStandardUriConformant(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getStandardUriConformant" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getStandardUriConformant();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getPSVIHandler) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::PSVIHandler *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getPSVIHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getPSVIHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::PSVIHandler *)(arg1)->getPSVIHandler();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getCreateSchemaInfo) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getCreateSchemaInfo(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getCreateSchemaInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getCreateSchemaInfo();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getGenerateSyntheticAnnotations) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getGenerateSyntheticAnnotations(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getGenerateSyntheticAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getGenerateSyntheticAnnotations();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getValidateAnnotations) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getValidateAnnotations(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getValidateAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getValidateAnnotations();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getIgnoreAnnotations) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getIgnoreAnnotations(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getIgnoreAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getIgnoreAnnotations();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getDisableDefaultEntityResolution) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getDisableDefaultEntityResolution(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getDisableDefaultEntityResolution" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getDisableDefaultEntityResolution();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_getSkipDTDValidation) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: AbstractDOMParser_getSkipDTDValidation(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_getSkipDTDValidation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::AbstractDOMParser const *)arg1)->getSkipDTDValidation();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setGenerateSyntheticAnnotations) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setGenerateSyntheticAnnotations(self,newValue);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setGenerateSyntheticAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setGenerateSyntheticAnnotations" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setGenerateSyntheticAnnotations(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setValidateAnnotations) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setValidateAnnotations(self,newValue);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setValidateAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setValidateAnnotations" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setValidateAnnotations(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setDoNamespaces) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setDoNamespaces(self,newState);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setDoNamespaces" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setDoNamespaces" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setDoNamespaces(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setExitOnFirstFatalError) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setExitOnFirstFatalError(self,newState);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setExitOnFirstFatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setExitOnFirstFatalError" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setExitOnFirstFatalError(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setValidationConstraintFatal) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setValidationConstraintFatal(self,newState);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setValidationConstraintFatal" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setValidationConstraintFatal" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setValidationConstraintFatal(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setCreateEntityReferenceNodes) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setCreateEntityReferenceNodes(self,create);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setCreateEntityReferenceNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setCreateEntityReferenceNodes" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setCreateEntityReferenceNodes(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setIncludeIgnorableWhitespace) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setIncludeIgnorableWhitespace(self,include);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setIncludeIgnorableWhitespace" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setIncludeIgnorableWhitespace" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setIncludeIgnorableWhitespace(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setValidationScheme) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::AbstractDOMParser::ValSchemes arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setValidationScheme(self,newScheme);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setValidationScheme" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setValidationScheme" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser::ValSchemes""'");
- }
- arg2 = static_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser::ValSchemes >(val2);
- {
- try
- {
- (arg1)->setValidationScheme(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setDoSchema) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setDoSchema(self,newState);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setDoSchema" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setDoSchema" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setDoSchema(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setValidationSchemaFullChecking) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setValidationSchemaFullChecking(self,schemaFullChecking);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setValidationSchemaFullChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setValidationSchemaFullChecking" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setValidationSchemaFullChecking(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setIdentityConstraintChecking) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setIdentityConstraintChecking(self,newState);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setIdentityConstraintChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setIdentityConstraintChecking" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setIdentityConstraintChecking(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setExternalSchemaLocation) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setExternalSchemaLocation(self,schemaLocation);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setExternalSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_setExternalSchemaLocation");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setExternalSchemaLocation((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setExternalNoNamespaceSchemaLocation) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setExternalNoNamespaceSchemaLocation(self,noNamespaceSchemaLocation);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setExternalNoNamespaceSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_setExternalNoNamespaceSchemaLocation");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->setExternalNoNamespaceSchemaLocation((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setSecurityManager) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- SecurityManager *arg2 = (SecurityManager *) (SecurityManager *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setSecurityManager(self,securityManager);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setSecurityManager" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_SecurityManager, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_setSecurityManager" "', argument " "2"" of type '" "SecurityManager *const""'");
- }
- arg2 = reinterpret_cast< SecurityManager * >(argp2);
- {
- try
- {
- (arg1)->setSecurityManager(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setLoadExternalDTD) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setLoadExternalDTD(self,newState);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setLoadExternalDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setLoadExternalDTD" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setLoadExternalDTD(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setCreateCommentNodes) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setCreateCommentNodes(self,create);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setCreateCommentNodes" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setCreateCommentNodes" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setCreateCommentNodes(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setCalculateSrcOfs) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setCalculateSrcOfs(self,newState);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setCalculateSrcOfs" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setCalculateSrcOfs" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setCalculateSrcOfs(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setStandardUriConformant) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setStandardUriConformant(self,newState);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setStandardUriConformant" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setStandardUriConformant" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setStandardUriConformant(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_useScanner) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_useScanner(self,scannerName);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_useScanner" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_useScanner");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->useScanner((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_useImplementation) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_useImplementation(self,implementationFeatures);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_useImplementation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_useImplementation");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->useImplementation((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setPSVIHandler) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::PSVIHandler *arg2 = (XERCES_CPP_NAMESPACE::PSVIHandler *) (XERCES_CPP_NAMESPACE::PSVIHandler *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setPSVIHandler(self,handler);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setPSVIHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_setPSVIHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::PSVIHandler *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::PSVIHandler * >(argp2);
- {
- try
- {
- (arg1)->setPSVIHandler(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setCreateSchemaInfo) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setCreateSchemaInfo(self,newState);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setCreateSchemaInfo" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setCreateSchemaInfo" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setCreateSchemaInfo(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setIgnoreAnnotations) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setIgnoreAnnotations(self,newValue);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setIgnoreAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setIgnoreAnnotations" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setIgnoreAnnotations(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setDisableDefaultEntityResolution) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setDisableDefaultEntityResolution(self,newValue);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setDisableDefaultEntityResolution" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setDisableDefaultEntityResolution" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setDisableDefaultEntityResolution(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_setSkipDTDValidation) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_setSkipDTDValidation(self,newValue);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_setSkipDTDValidation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractDOMParser_setSkipDTDValidation" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setSkipDTDValidation(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_parse__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::InputSource *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_parse(self,source);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_parse" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parse" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
- {
- try
- {
- (arg1)->parse((XERCES_CPP_NAMESPACE::InputSource const &)*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_parse__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_parse(self,systemId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_parse");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- (arg1)->parse((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_parse) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 2) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AbstractDOMParser_parse__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AbstractDOMParser_parse__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'AbstractDOMParser_parse'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_AbstractDOMParser_parseFirst__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XERCES_CPP_NAMESPACE::XMLPScanToken *arg3 = 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: AbstractDOMParser_parseFirst(self,systemId,toFill);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_parseFirst");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
- }
- if (!argp3) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
- }
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp3);
- {
- try
- {
- result = (bool)(arg1)->parseFirst((XMLCh const *)arg2,*arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
- delete[] arg2;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_parseFirst__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- char *arg2 = (char *) (char *)0 ;
- XERCES_CPP_NAMESPACE::XMLPScanToken *arg3 = 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: AbstractDOMParser_parseFirst(self,systemId,toFill);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_parseFirst" "', argument " "2"" of type '" "char const *const""'");
- }
- arg2 = reinterpret_cast< char * >(buf2);
- res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
- }
- if (!argp3) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
- }
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp3);
- {
- try
- {
- result = (bool)(arg1)->parseFirst((char const *)arg2,*arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-
- XSRETURN(argvi);
- fail:
-
- if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_parseFirst__SWIG_2) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::InputSource *arg2 = 0 ;
- XERCES_CPP_NAMESPACE::XMLPScanToken *arg3 = 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: AbstractDOMParser_parseFirst(self,source,toFill);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_parseFirst" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseFirst" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
- res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
- }
- if (!argp3) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
- }
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp3);
- {
- try
- {
- result = (bool)(arg1)->parseFirst((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,*arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_parseFirst) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- int res = SWIG_AsCharPtrAndSize(ST(1), 0, NULL, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 3;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_3:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AbstractDOMParser_parseFirst__SWIG_2); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AbstractDOMParser_parseFirst__SWIG_0); return;
- case 3:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_AbstractDOMParser_parseFirst__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'AbstractDOMParser_parseFirst'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_AbstractDOMParser_parseNext) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::XMLPScanToken *arg2 = 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_parseNext(self,token);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parseNext" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_parseNext" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseNext" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp2);
- {
- try
- {
- result = (bool)(arg1)->parseNext(*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_parseReset) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::XMLPScanToken *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: AbstractDOMParser_parseReset(self,token);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_parseReset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractDOMParser_parseReset" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractDOMParser_parseReset" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp2);
- {
- try
- {
- (arg1)->parseReset(*arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_handleElementPSVI) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- PSVIElement *arg4 = (PSVIElement *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: AbstractDOMParser_handleElementPSVI(self,localName,uri,elementInfo);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_handleElementPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_handleElementPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"AbstractDOMParser_handleElementPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIElement, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AbstractDOMParser_handleElementPSVI" "', argument " "4"" of type '" "PSVIElement *""'");
- }
- arg4 = reinterpret_cast< PSVIElement * >(argp4);
- {
- try
- {
- (arg1)->handleElementPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_handlePartialElementPSVI) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- PSVIElement *arg4 = (PSVIElement *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: AbstractDOMParser_handlePartialElementPSVI(self,localName,uri,elementInfo);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_handlePartialElementPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_handlePartialElementPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"AbstractDOMParser_handlePartialElementPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIElement, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AbstractDOMParser_handlePartialElementPSVI" "', argument " "4"" of type '" "PSVIElement *""'");
- }
- arg4 = reinterpret_cast< PSVIElement * >(argp4);
- {
- try
- {
- (arg1)->handlePartialElementPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_AbstractDOMParser_handleAttributesPSVI) {
- {
- XERCES_CPP_NAMESPACE::AbstractDOMParser *arg1 = (XERCES_CPP_NAMESPACE::AbstractDOMParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- PSVIAttributeList *arg4 = (PSVIAttributeList *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: AbstractDOMParser_handleAttributesPSVI(self,localName,uri,psviAttributes);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractDOMParser_handleAttributesPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::AbstractDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::AbstractDOMParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"AbstractDOMParser_handleAttributesPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"AbstractDOMParser_handleAttributesPSVI");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIAttributeList, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AbstractDOMParser_handleAttributesPSVI" "', argument " "4"" of type '" "PSVIAttributeList *""'");
- }
- arg4 = reinterpret_cast< PSVIAttributeList * >(argp4);
- {
- try
- {
- (arg1)->handleAttributesPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
-
- delete[] arg3;
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_XercesDOMParser__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::XMLValidator *arg1 = (XERCES_CPP_NAMESPACE::XMLValidator *) (XERCES_CPP_NAMESPACE::XMLValidator *)0 ;
- XERCES_CPP_NAMESPACE::MemoryManager *arg2 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
- XERCES_CPP_NAMESPACE::XMLGrammarPool *arg3 = (XERCES_CPP_NAMESPACE::XMLGrammarPool *) (XERCES_CPP_NAMESPACE::XMLGrammarPool *)0 ;
- XERCES_CPP_NAMESPACE::XercesDOMParser *result = 0 ;
- SV *temp1 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- arg2 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
- if ((items < 1) || (items > 3)) {
- SWIG_croak("Usage: new_XercesDOMParser(valToAdopt,manager,gramPool);");
- }
- {
- temp1 = ST(0);
- if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator,0) < 0) {
- SWIG_Perl_TypeError("_p_XERCES_CPP_NAMESPACE__XMLValidator",1,"new_XercesDOMParser");
- }
- }
- if (items > 1) {
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_XercesDOMParser" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp2);
- }
- if (items > 2) {
- res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XercesDOMParser" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLGrammarPool *const""'");
- }
- arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLGrammarPool * >(argp3);
- }
- {
- SWIG_Disown(temp1);
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::XercesDOMParser *)new XERCES_CPP_NAMESPACE::XercesDOMParser(arg1,arg2,arg3);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_XercesDOMParser__SWIG_1) {
- {
- XERCES_CPP_NAMESPACE::XMLValidator *arg1 = (XERCES_CPP_NAMESPACE::XMLValidator *) (XERCES_CPP_NAMESPACE::XMLValidator *)0 ;
- XERCES_CPP_NAMESPACE::XercesDOMParser *result = 0 ;
- SV *temp1 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_XercesDOMParser(valToAdopt);");
- }
- {
- temp1 = ST(0);
- if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator,0) < 0) {
- SWIG_Perl_TypeError("_p_XERCES_CPP_NAMESPACE__XMLValidator",1,"new_XercesDOMParser");
- }
- }
- {
- SWIG_Disown(temp1);
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::XercesDOMParser *)new XERCES_CPP_NAMESPACE::XercesDOMParser(arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_XercesDOMParser__SWIG_2) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 0) || (items > 0)) {
- SWIG_croak("Usage: new_XercesDOMParser();");
- }
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::XercesDOMParser *)new XERCES_CPP_NAMESPACE::XercesDOMParser();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_XercesDOMParser) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 0) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- if (items == 1) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- if ((items >= 1) && (items <= 3)) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (items > 1) {
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (items > 2) {
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- }
- }
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 3;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_3:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XercesDOMParser__SWIG_2); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XercesDOMParser__SWIG_1); return;
- case 3:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XercesDOMParser__SWIG_0); return;
- }
- }
-
- croak("No matching function for overloaded 'new_XercesDOMParser'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_delete_XercesDOMParser) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_XercesDOMParser(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XercesDOMParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_getErrorHandler) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::ErrorHandler *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: XercesDOMParser_getErrorHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::ErrorHandler *)(arg1)->getErrorHandler();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_getEntityResolver) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::EntityResolver *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: XercesDOMParser_getEntityResolver(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::EntityResolver *)(arg1)->getEntityResolver();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__EntityResolver, 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_getXMLEntityResolver) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::XMLEntityResolver *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: XercesDOMParser_getXMLEntityResolver(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getXMLEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::XMLEntityResolver *)(arg1)->getXMLEntityResolver();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityResolver, 0 | 0); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_isCachingGrammarFromParse) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: XercesDOMParser_isCachingGrammarFromParse(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_isCachingGrammarFromParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::XercesDOMParser const *)arg1)->isCachingGrammarFromParse();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_isUsingCachedGrammarInParse) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: XercesDOMParser_isUsingCachedGrammarInParse(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_isUsingCachedGrammarInParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::XercesDOMParser const *)arg1)->isUsingCachedGrammarInParse();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_getGrammar) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: XercesDOMParser_getGrammar(self,nameSpaceKey);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"XercesDOMParser_getGrammar");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getGrammar((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
- delete[] arg2;
-
- XSRETURN(argvi);
- fail:
-
-
- delete[] arg2;
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_getRootGrammar) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: XercesDOMParser_getRootGrammar(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getRootGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- {
- try
- {
- result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getRootGrammar();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_getURIText) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- unsigned int arg2 ;
- XMLCh *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: XercesDOMParser_getURIText(self,uriId);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getURIText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XercesDOMParser_getURIText" "', argument " "2"" of type '" "unsigned int""'");
- }
- arg2 = static_cast< unsigned int >(val2);
- {
- try
- {
- result = (XMLCh *)((XERCES_CPP_NAMESPACE::XercesDOMParser const *)arg1)->getURIText(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
- ST(argvi) = XMLString2Perl(result);
- ++argvi;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_getSrcOffset) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- unsigned int result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: XercesDOMParser_getSrcOffset(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getSrcOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- {
- try
- {
- result = (unsigned int)((XERCES_CPP_NAMESPACE::XercesDOMParser const *)arg1)->getSrcOffset();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_getIgnoreCachedDTD) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- bool result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: XercesDOMParser_getIgnoreCachedDTD(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_getIgnoreCachedDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser const *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- {
- try
- {
- result = (bool)((XERCES_CPP_NAMESPACE::XercesDOMParser const *)arg1)->getIgnoreCachedDTD();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_setErrorHandler) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::ErrorHandler *arg2 = (XERCES_CPP_NAMESPACE::ErrorHandler *) (XERCES_CPP_NAMESPACE::ErrorHandler *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: XercesDOMParser_setErrorHandler(self,handler);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_setErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XercesDOMParser_setErrorHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp2);
- {
- try
- {
- (arg1)->setErrorHandler(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_setEntityResolver) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::EntityResolver *arg2 = (XERCES_CPP_NAMESPACE::EntityResolver *) (XERCES_CPP_NAMESPACE::EntityResolver *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: XercesDOMParser_setEntityResolver(self,handler);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_setEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__EntityResolver, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XercesDOMParser_setEntityResolver" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::EntityResolver *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::EntityResolver * >(argp2);
- {
- try
- {
- (arg1)->setEntityResolver(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_setXMLEntityResolver) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::XMLEntityResolver *arg2 = (XERCES_CPP_NAMESPACE::XMLEntityResolver *) (XERCES_CPP_NAMESPACE::XMLEntityResolver *)0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: XercesDOMParser_setXMLEntityResolver(self,handler);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_setXMLEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityResolver, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XercesDOMParser_setXMLEntityResolver" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLEntityResolver *const""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLEntityResolver * >(argp2);
- {
- try
- {
- (arg1)->setXMLEntityResolver(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_cacheGrammarFromParse) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: XercesDOMParser_cacheGrammarFromParse(self,newState);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_cacheGrammarFromParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XercesDOMParser_cacheGrammarFromParse" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->cacheGrammarFromParse(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_useCachedGrammarInParse) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: XercesDOMParser_useCachedGrammarInParse(self,newState);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_useCachedGrammarInParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XercesDOMParser_useCachedGrammarInParse" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->useCachedGrammarInParse(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_setIgnoreCachedDTD) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- bool arg2 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- bool val2 ;
- int ecode2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: XercesDOMParser_setIgnoreCachedDTD(self,newValue);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_setIgnoreCachedDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XercesDOMParser_setIgnoreCachedDTD" "', argument " "2"" of type '" "bool""'");
- }
- arg2 = static_cast< bool >(val2);
- {
- try
- {
- (arg1)->setIgnoreCachedDTD(arg2);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_resetDocumentPool) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: XercesDOMParser_resetDocumentPool(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_resetDocumentPool" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- {
- try
- {
- (arg1)->resetDocumentPool();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_error) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- unsigned int arg2 ;
- XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
- XMLErrorReporter::ErrTypes arg4 ;
- XMLCh *arg5 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg6 = (XMLCh *) (XMLCh *)0 ;
- XMLCh *arg7 = (XMLCh *) (XMLCh *)0 ;
- XMLSSize_t arg8 ;
- XMLSSize_t arg9 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- unsigned int val2 ;
- int ecode2 = 0 ;
- void *argp4 ;
- int res4 = 0 ;
- size_t val8 ;
- int ecode8 = 0 ;
- size_t val9 ;
- int ecode9 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 9) || (items > 9)) {
- SWIG_croak("Usage: XercesDOMParser_error(self,errCode,msgDomain,errType,errorText,systemId,publicId,lineNum,colNum);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_error" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XercesDOMParser_error" "', argument " "2"" of type '" "unsigned int""'");
- }
- arg2 = static_cast< unsigned int >(val2);
-
- if (ST(2) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",3,"XercesDOMParser_error");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
- }
-
- {
- res4 = SWIG_ConvertPtr(ST(3), &argp4, SWIGTYPE_p_XMLErrorReporter__ErrTypes, 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XercesDOMParser_error" "', argument " "4"" of type '" "XMLErrorReporter::ErrTypes const""'");
- }
- if (!argp4) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XercesDOMParser_error" "', argument " "4"" of type '" "XMLErrorReporter::ErrTypes const""'");
- } else {
- arg4 = *(reinterpret_cast< XMLErrorReporter::ErrTypes * >(argp4));
- }
- }
-
- if (ST(4) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",5,"XercesDOMParser_error");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
- }
-
-
- if (ST(5) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",6,"XercesDOMParser_error");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg6 = Perl2XMLString(ST(5));
- }
-
-
- if (ST(6) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",7,"XercesDOMParser_error");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg7 = Perl2XMLString(ST(6));
- }
-
- ecode8 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(7), &val8);
- if (!SWIG_IsOK(ecode8)) {
- SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "XercesDOMParser_error" "', argument " "8"" of type '" "XMLSSize_t""'");
- }
- arg8 = static_cast< XMLSSize_t >(val8);
- ecode9 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(8), &val9);
- if (!SWIG_IsOK(ecode9)) {
- SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "XercesDOMParser_error" "', argument " "9"" of type '" "XMLSSize_t""'");
- }
- arg9 = static_cast< XMLSSize_t >(val9);
- {
- try
- {
- (arg1)->error(arg2,(XMLCh const *)arg3,arg4,(XMLCh const *)arg5,(XMLCh const *)arg6,(XMLCh const *)arg7,arg8,arg9);
- }
- CATCH_DOM_EXCEPTION
- }
-
-
-
-
- delete[] arg3;
-
-
- delete[] arg5;
-
-
- delete[] arg6;
-
-
- delete[] arg7;
-
-
-
- XSRETURN(argvi);
- fail:
-
-
-
- delete[] arg3;
-
-
- delete[] arg5;
-
-
- delete[] arg6;
-
-
- delete[] arg7;
-
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_resetErrors) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: XercesDOMParser_resetErrors(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_resetErrors" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- {
- try
- {
- (arg1)->resetErrors();
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_loadGrammar__SWIG_0) {
- {
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::InputSource *arg2 = 0 ;
- short arg3 ;
- bool arg4 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- short val3 ;
- int ecode3 = 0 ;
- bool val4 ;
- int ecode4 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: XercesDOMParser_loadGrammar(self,source,grammarType,toCache);");
+ SWIG_croak("Usage: delete_XMLPScanToken(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XercesDOMParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XercesDOMParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLPScanToken" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken *""'");
}
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
- ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XercesDOMParser_loadGrammar" "', argument " "3"" of type '" "short""'");
- }
- arg3 = static_cast< short >(val3);
- ecode4 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XercesDOMParser_loadGrammar" "', argument " "4"" of type '" "bool""'");
- }
- arg4 = static_cast< bool >(val4);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,arg3,arg4);
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
-
XSRETURN(argvi);
fail:
-
-
-
SWIG_croak_null();
}
}
-XS(_wrap_XercesDOMParser_loadGrammar__SWIG_1) {
+XS(_wrap_delete_PSVIHandler) {
{
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
- XERCES_CPP_NAMESPACE::InputSource *arg2 = 0 ;
- short arg3 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ XERCES_CPP_NAMESPACE::PSVIHandler *arg1 = (XERCES_CPP_NAMESPACE::PSVIHandler *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp2 ;
- int res2 = 0 ;
- short val3 ;
- int ecode3 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: XercesDOMParser_loadGrammar(self,source,grammarType);");
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_PSVIHandler(self);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
- }
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XercesDOMParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
- }
- if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XercesDOMParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PSVIHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PSVIHandler *""'");
}
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp2);
- ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XercesDOMParser_loadGrammar" "', argument " "3"" of type '" "short""'");
- }
- arg3 = static_cast< short >(val3);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PSVIHandler * >(argp1);
{
try
{
- result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,arg3);
+ delete arg1;
+
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
-
XSRETURN(argvi);
fail:
-
-
SWIG_croak_null();
}
}
-XS(_wrap_XercesDOMParser_loadGrammar__SWIG_2) {
+XS(_wrap_PSVIHandler_handleElementPSVI) {
{
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::PSVIHandler *arg1 = (XERCES_CPP_NAMESPACE::PSVIHandler *) 0 ;
XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- short arg3 ;
- bool arg4 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ PSVIElement *arg4 = (PSVIElement *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- short val3 ;
- int ecode3 = 0 ;
- bool val4 ;
- int ecode4 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
int argvi = 0;
dXSARGS;
if ((items < 4) || (items > 4)) {
- SWIG_croak("Usage: XercesDOMParser_loadGrammar(self,systemId,grammarType,toCache);");
+ SWIG_croak("Usage: PSVIHandler_handleElementPSVI(self,localName,uri,elementInfo);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PSVIHandler_handleElementPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PSVIHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PSVIHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"XercesDOMParser_loadGrammar");
+ SWIG_Perl_NullRef("perl-string",2,"PSVIHandler_handleElementPSVI");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XercesDOMParser_loadGrammar" "', argument " "3"" of type '" "short""'");
- }
- arg3 = static_cast< short >(val3);
- ecode4 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XercesDOMParser_loadGrammar" "', argument " "4"" of type '" "bool""'");
- }
- arg4 = static_cast< bool >(val4);
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"PSVIHandler_handleElementPSVI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIElement, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PSVIHandler_handleElementPSVI" "', argument " "4"" of type '" "PSVIElement *""'");
+ }
+ arg4 = reinterpret_cast< PSVIElement * >(argp4);
{
try
{
- result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3,arg4);
+ (arg1)->handleElementPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
delete[] arg2;
+ delete[] arg3;
+
XSRETURN(argvi);
fail:
@@ -58633,60 +34145,74 @@ XS(_wrap_XercesDOMParser_loadGrammar__SWIG_2) {
delete[] arg2;
+ delete[] arg3;
+
SWIG_croak_null();
}
}
-XS(_wrap_XercesDOMParser_loadGrammar__SWIG_3) {
+XS(_wrap_PSVIHandler_handlePartialElementPSVI) {
{
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::PSVIHandler *arg1 = (XERCES_CPP_NAMESPACE::PSVIHandler *) 0 ;
XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
- short arg3 ;
- XERCES_CPP_NAMESPACE::Grammar *result = 0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ PSVIElement *arg4 = (PSVIElement *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- short val3 ;
- int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 3) || (items > 3)) {
- SWIG_croak("Usage: XercesDOMParser_loadGrammar(self,systemId,grammarType);");
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: PSVIHandler_handlePartialElementPSVI(self,localName,uri,elementInfo);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PSVIHandler_handlePartialElementPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PSVIHandler *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PSVIHandler * >(argp1);
if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"XercesDOMParser_loadGrammar");
+ SWIG_Perl_NullRef("perl-string",2,"PSVIHandler_handlePartialElementPSVI");
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
- ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XercesDOMParser_loadGrammar" "', argument " "3"" of type '" "short""'");
- }
- arg3 = static_cast< short >(val3);
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"PSVIHandler_handlePartialElementPSVI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIElement, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PSVIHandler_handlePartialElementPSVI" "', argument " "4"" of type '" "PSVIElement *""'");
+ }
+ arg4 = reinterpret_cast< PSVIElement * >(argp4);
{
try
{
- result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3);
+ (arg1)->handlePartialElementPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
+
delete[] arg2;
+ delete[] arg3;
+
+
XSRETURN(argvi);
fail:
@@ -58694,243 +34220,84 @@ XS(_wrap_XercesDOMParser_loadGrammar__SWIG_3) {
delete[] arg2;
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_XercesDOMParser_loadGrammar) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_1;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_1:
-
- if (items == 3) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- if (items == 4) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_3;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 3;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_3:
+ delete[] arg3;
- if (items == 4) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- void *vptr = 0;
- int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0);
- _v = SWIG_CheckState(res);
- }
- if (!_v) goto check_4;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- _v = SvOK(ST(1)) ? 1 : 0;
- }
- }
- if (!_v) goto check_4;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_4;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- {
- {
- int res = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
- _v = SWIG_CheckState(res);
- }
- }
- if (!_v) goto check_4;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 4;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_4:
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XercesDOMParser_loadGrammar__SWIG_1); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XercesDOMParser_loadGrammar__SWIG_3); return;
- case 3:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XercesDOMParser_loadGrammar__SWIG_0); return;
- case 4:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XercesDOMParser_loadGrammar__SWIG_2); return;
- }
+ SWIG_croak_null();
}
-
- croak("No matching function for overloaded 'XercesDOMParser_loadGrammar'");
- XSRETURN(0);
}
-XS(_wrap_XercesDOMParser_resetCachedGrammarPool) {
+XS(_wrap_PSVIHandler_handleAttributesPSVI) {
{
- XERCES_CPP_NAMESPACE::XercesDOMParser *arg1 = (XERCES_CPP_NAMESPACE::XercesDOMParser *) 0 ;
+ XERCES_CPP_NAMESPACE::PSVIHandler *arg1 = (XERCES_CPP_NAMESPACE::PSVIHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ PSVIAttributeList *arg4 = (PSVIAttributeList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: XercesDOMParser_resetCachedGrammarPool(self);");
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: PSVIHandler_handleAttributesPSVI(self,localName,uri,psviAttributes);");
}
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0 | 0 );
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XercesDOMParser_resetCachedGrammarPool" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XercesDOMParser *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PSVIHandler_handleAttributesPSVI" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PSVIHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PSVIHandler * >(argp1);
+
+ if (ST(1) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",2,"PSVIHandler_handleAttributesPSVI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
+ }
+
+
+ if (ST(2) == &PL_sv_undef) {
+ SWIG_Perl_NullRef("perl-string",3,"PSVIHandler_handleAttributesPSVI");
+ goto fail;
+ } else {
+ // we convert *everything* into a string that isn't undef
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
+ }
+
+ res4 = SWIG_ConvertPtr(ST(3), &argp4,SWIGTYPE_p_PSVIAttributeList, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PSVIHandler_handleAttributesPSVI" "', argument " "4"" of type '" "PSVIAttributeList *""'");
}
- arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XercesDOMParser * >(argp1);
+ arg4 = reinterpret_cast< PSVIAttributeList * >(argp4);
{
try
{
- (arg1)->resetCachedGrammarPool();
+ (arg1)->handleAttributesPSVI((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
XSRETURN(argvi);
fail:
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
SWIG_croak_null();
}
}
@@ -58958,7 +34325,7 @@ XS(_wrap_delete_Parser) {
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -58999,7 +34366,7 @@ XS(_wrap_Parser_setEntityResolver) {
{
(arg1)->setEntityResolver(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -59042,7 +34409,7 @@ XS(_wrap_Parser_setDTDHandler) {
{
(arg1)->setDTDHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -59085,7 +34452,7 @@ XS(_wrap_Parser_setDocumentHandler) {
{
(arg1)->setDocumentHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -59128,7 +34495,7 @@ XS(_wrap_Parser_setErrorHandler) {
{
(arg1)->setErrorHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -59174,7 +34541,7 @@ XS(_wrap_Parser_parse__SWIG_0) {
{
(arg1)->parse((XERCES_CPP_NAMESPACE::InputSource const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -59211,7 +34578,7 @@ XS(_wrap_Parser_parse__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -59219,7 +34586,7 @@ XS(_wrap_Parser_parse__SWIG_1) {
{
(arg1)->parse((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -59363,7 +34730,7 @@ XS(_wrap_new_SAXParser__SWIG_0) {
{
result = (XERCES_CPP_NAMESPACE::SAXParser *)new XERCES_CPP_NAMESPACE::SAXParser(arg1,arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
@@ -59415,7 +34782,7 @@ XS(_wrap_new_SAXParser__SWIG_1) {
{
result = (XERCES_CPP_NAMESPACE::SAXParser *)new XERCES_CPP_NAMESPACE::SAXParser(arg1,arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
@@ -59443,7 +34810,7 @@ XS(_wrap_new_SAXParser__SWIG_2) {
{
result = (XERCES_CPP_NAMESPACE::SAXParser *)new XERCES_CPP_NAMESPACE::SAXParser();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
@@ -59580,7 +34947,7 @@ XS(_wrap_delete_SAXParser) {
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -59614,7 +34981,7 @@ XS(_wrap_SAXParser_getDocumentHandler) {
{
result = (XERCES_CPP_NAMESPACE::DocumentHandler *)(arg1)->getDocumentHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0 | SWIG_SHADOW); argvi++ ;
@@ -59648,7 +35015,7 @@ XS(_wrap_SAXParser_getEntityResolver) {
{
result = (XERCES_CPP_NAMESPACE::EntityResolver *)(arg1)->getEntityResolver();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__EntityResolver, 0 | SWIG_SHADOW); argvi++ ;
@@ -59682,7 +35049,7 @@ XS(_wrap_SAXParser_getXMLEntityResolver) {
{
result = (XERCES_CPP_NAMESPACE::XMLEntityResolver *)(arg1)->getXMLEntityResolver();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityResolver, 0 | 0); argvi++ ;
@@ -59716,7 +35083,7 @@ XS(_wrap_SAXParser_getErrorHandler) {
{
result = (XERCES_CPP_NAMESPACE::ErrorHandler *)(arg1)->getErrorHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler, 0 | SWIG_SHADOW); argvi++ ;
@@ -59750,7 +35117,7 @@ XS(_wrap_SAXParser_getPSVIHandler) {
{
result = (XERCES_CPP_NAMESPACE::PSVIHandler *)(arg1)->getPSVIHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0 | SWIG_SHADOW); argvi++ ;
@@ -59787,7 +35154,7 @@ XS(_wrap_SAXParser_getValidator) {
result = (XERCES_CPP_NAMESPACE::XMLValidator *) &_result_ref;
}
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator, 0 | SWIG_SHADOW); argvi++ ;
@@ -59821,7 +35188,7 @@ XS(_wrap_SAXParser_getValidationScheme) {
{
result = (XERCES_CPP_NAMESPACE::SAXParser::ValSchemes)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getValidationScheme();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
@@ -59855,7 +35222,7 @@ XS(_wrap_SAXParser_getDoSchema) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getDoSchema();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -59889,7 +35256,7 @@ XS(_wrap_SAXParser_getValidationSchemaFullChecking) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getValidationSchemaFullChecking();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -59923,7 +35290,7 @@ XS(_wrap_SAXParser_getIdentityConstraintChecking) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getIdentityConstraintChecking();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -59957,7 +35324,7 @@ XS(_wrap_SAXParser_getErrorCount) {
{
result = (int)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getErrorCount();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
@@ -59991,7 +35358,7 @@ XS(_wrap_SAXParser_getDoNamespaces) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getDoNamespaces();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60025,7 +35392,7 @@ XS(_wrap_SAXParser_getExitOnFirstFatalError) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getExitOnFirstFatalError();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60059,7 +35426,7 @@ XS(_wrap_SAXParser_getValidationConstraintFatal) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getValidationConstraintFatal();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60093,10 +35460,10 @@ XS(_wrap_SAXParser_getExternalSchemaLocation) {
{
result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getExternalSchemaLocation();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -60130,10 +35497,10 @@ XS(_wrap_SAXParser_getExternalNoNamespaceSchemaLocation) {
{
result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getExternalNoNamespaceSchemaLocation();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -60167,7 +35534,7 @@ XS(_wrap_SAXParser_getSecurityManager) {
{
result = (SecurityManager *)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getSecurityManager();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SecurityManager, 0 | 0); argvi++ ;
@@ -60201,7 +35568,7 @@ XS(_wrap_SAXParser_getLoadExternalDTD) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getLoadExternalDTD();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60235,7 +35602,7 @@ XS(_wrap_SAXParser_isCachingGrammarFromParse) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->isCachingGrammarFromParse();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60269,7 +35636,7 @@ XS(_wrap_SAXParser_isUsingCachedGrammarInParse) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->isUsingCachedGrammarInParse();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60303,7 +35670,7 @@ XS(_wrap_SAXParser_getCalculateSrcOfs) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getCalculateSrcOfs();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60337,7 +35704,7 @@ XS(_wrap_SAXParser_getStandardUriConformant) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getStandardUriConformant();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60373,7 +35740,7 @@ XS(_wrap_SAXParser_getGrammar) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -60381,7 +35748,7 @@ XS(_wrap_SAXParser_getGrammar) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getGrammar((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -60421,7 +35788,7 @@ XS(_wrap_SAXParser_getRootGrammar) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getRootGrammar();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -60463,10 +35830,10 @@ XS(_wrap_SAXParser_getURIText) {
{
result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getURIText(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -60502,7 +35869,7 @@ XS(_wrap_SAXParser_getSrcOffset) {
{
result = (unsigned int)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getSrcOffset();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
@@ -60536,7 +35903,7 @@ XS(_wrap_SAXParser_getGenerateSyntheticAnnotations) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getGenerateSyntheticAnnotations();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60570,7 +35937,7 @@ XS(_wrap_SAXParser_getValidateAnnotations) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getValidateAnnotations();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60604,7 +35971,7 @@ XS(_wrap_SAXParser_getIgnoreCachedDTD) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getIgnoreCachedDTD();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60638,7 +36005,7 @@ XS(_wrap_SAXParser_getIgnoreAnnotations) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getIgnoreAnnotations();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60672,7 +36039,7 @@ XS(_wrap_SAXParser_getDisableDefaultEntityResolution) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getDisableDefaultEntityResolution();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60706,7 +36073,7 @@ XS(_wrap_SAXParser_getSkipDTDValidation) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getSkipDTDValidation();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -60747,7 +36114,7 @@ XS(_wrap_SAXParser_setGenerateSyntheticAnnotations) {
{
(arg1)->setGenerateSyntheticAnnotations(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -60790,7 +36157,7 @@ XS(_wrap_SAXParser_setValidateAnnotations) {
{
(arg1)->setValidateAnnotations(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -60833,7 +36200,7 @@ XS(_wrap_SAXParser_setDoNamespaces) {
{
(arg1)->setDoNamespaces(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -60876,7 +36243,7 @@ XS(_wrap_SAXParser_setValidationScheme) {
{
(arg1)->setValidationScheme(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -60919,7 +36286,7 @@ XS(_wrap_SAXParser_setDoSchema) {
{
(arg1)->setDoSchema(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -60962,7 +36329,7 @@ XS(_wrap_SAXParser_setValidationSchemaFullChecking) {
{
(arg1)->setValidationSchemaFullChecking(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61005,7 +36372,7 @@ XS(_wrap_SAXParser_setIdentityConstraintChecking) {
{
(arg1)->setIdentityConstraintChecking(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61048,7 +36415,7 @@ XS(_wrap_SAXParser_setExitOnFirstFatalError) {
{
(arg1)->setExitOnFirstFatalError(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61091,7 +36458,7 @@ XS(_wrap_SAXParser_setValidationConstraintFatal) {
{
(arg1)->setValidationConstraintFatal(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61128,7 +36495,7 @@ XS(_wrap_SAXParser_setExternalSchemaLocation) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -61136,7 +36503,7 @@ XS(_wrap_SAXParser_setExternalSchemaLocation) {
{
(arg1)->setExternalSchemaLocation((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61177,7 +36544,7 @@ XS(_wrap_SAXParser_setExternalNoNamespaceSchemaLocation) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -61185,7 +36552,7 @@ XS(_wrap_SAXParser_setExternalNoNamespaceSchemaLocation) {
{
(arg1)->setExternalNoNamespaceSchemaLocation((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61232,7 +36599,7 @@ XS(_wrap_SAXParser_setSecurityManager) {
{
(arg1)->setSecurityManager(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61275,7 +36642,7 @@ XS(_wrap_SAXParser_setLoadExternalDTD) {
{
(arg1)->setLoadExternalDTD(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61318,7 +36685,7 @@ XS(_wrap_SAXParser_cacheGrammarFromParse) {
{
(arg1)->cacheGrammarFromParse(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61361,7 +36728,7 @@ XS(_wrap_SAXParser_useCachedGrammarInParse) {
{
(arg1)->useCachedGrammarInParse(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61404,7 +36771,7 @@ XS(_wrap_SAXParser_setCalculateSrcOfs) {
{
(arg1)->setCalculateSrcOfs(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61447,7 +36814,7 @@ XS(_wrap_SAXParser_setStandardUriConformant) {
{
(arg1)->setStandardUriConformant(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61484,7 +36851,7 @@ XS(_wrap_SAXParser_useScanner) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -61492,7 +36859,7 @@ XS(_wrap_SAXParser_useScanner) {
{
(arg1)->useScanner((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61539,7 +36906,7 @@ XS(_wrap_SAXParser_setInputBufferSize) {
{
(arg1)->setInputBufferSize(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61582,7 +36949,7 @@ XS(_wrap_SAXParser_setIgnoreCachedDTD) {
{
(arg1)->setIgnoreCachedDTD(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61625,7 +36992,7 @@ XS(_wrap_SAXParser_setIgnoreAnnotations) {
{
(arg1)->setIgnoreAnnotations(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61668,7 +37035,7 @@ XS(_wrap_SAXParser_setDisableDefaultEntityResolution) {
{
(arg1)->setDisableDefaultEntityResolution(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61711,7 +37078,7 @@ XS(_wrap_SAXParser_setSkipDTDValidation) {
{
(arg1)->setSkipDTDValidation(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61754,7 +37121,7 @@ XS(_wrap_SAXParser_installAdvDocHandler) {
{
(arg1)->installAdvDocHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -61798,7 +37165,7 @@ XS(_wrap_SAXParser_removeAdvDocHandler) {
{
result = (bool)(arg1)->removeAdvDocHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -61839,7 +37206,7 @@ XS(_wrap_SAXParser_parseFirst__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
@@ -61855,7 +37222,7 @@ XS(_wrap_SAXParser_parseFirst__SWIG_0) {
{
result = (bool)(arg1)->parseFirst((XMLCh const *)arg2,*arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -61917,7 +37284,7 @@ XS(_wrap_SAXParser_parseFirst__SWIG_1) {
{
result = (bool)(arg1)->parseFirst((char const *)arg2,*arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -61977,7 +37344,7 @@ XS(_wrap_SAXParser_parseFirst__SWIG_2) {
{
result = (bool)(arg1)->parseFirst((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,*arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -62164,7 +37531,7 @@ XS(_wrap_SAXParser_parseNext) {
{
result = (bool)(arg1)->parseNext(*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -62210,7 +37577,7 @@ XS(_wrap_SAXParser_parseReset) {
{
(arg1)->parseReset(*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -62273,7 +37640,7 @@ XS(_wrap_SAXParser_loadGrammar__SWIG_0) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,arg3,arg4);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -62332,7 +37699,7 @@ XS(_wrap_SAXParser_loadGrammar__SWIG_1) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -62378,7 +37745,7 @@ XS(_wrap_SAXParser_loadGrammar__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -62396,7 +37763,7 @@ XS(_wrap_SAXParser_loadGrammar__SWIG_2) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3,arg4);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -62445,7 +37812,7 @@ XS(_wrap_SAXParser_loadGrammar__SWIG_3) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -62458,7 +37825,7 @@ XS(_wrap_SAXParser_loadGrammar__SWIG_3) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -62703,7 +38070,7 @@ XS(_wrap_SAXParser_resetCachedGrammarPool) {
{
(arg1)->resetCachedGrammarPool();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -62747,7 +38114,7 @@ XS(_wrap_SAXParser_parse__SWIG_0) {
{
(arg1)->parse((XERCES_CPP_NAMESPACE::InputSource const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -62784,7 +38151,7 @@ XS(_wrap_SAXParser_parse__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -62792,7 +38159,7 @@ XS(_wrap_SAXParser_parse__SWIG_1) {
{
(arg1)->parse((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -62919,7 +38286,7 @@ XS(_wrap_SAXParser_setDocumentHandler) {
{
(arg1)->setDocumentHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -62962,7 +38329,7 @@ XS(_wrap_SAXParser_setDTDHandler) {
{
(arg1)->setDTDHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63005,7 +38372,7 @@ XS(_wrap_SAXParser_setErrorHandler) {
{
(arg1)->setErrorHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63048,7 +38415,7 @@ XS(_wrap_SAXParser_setPSVIHandler) {
{
(arg1)->setPSVIHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63091,7 +38458,7 @@ XS(_wrap_SAXParser_setEntityResolver) {
{
(arg1)->setEntityResolver(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63134,7 +38501,7 @@ XS(_wrap_SAXParser_setXMLEntityResolver) {
{
(arg1)->setXMLEntityResolver(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63191,7 +38558,7 @@ XS(_wrap_SAXParser_error) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -63211,7 +38578,7 @@ XS(_wrap_SAXParser_error) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg5 = Perl2XMLString(ST(4));
+ arg5 = UTF8_TRANSCODER->Perl2XMLString(ST(4));
}
@@ -63220,7 +38587,7 @@ XS(_wrap_SAXParser_error) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg6 = Perl2XMLString(ST(5));
+ arg6 = UTF8_TRANSCODER->Perl2XMLString(ST(5));
}
@@ -63229,7 +38596,7 @@ XS(_wrap_SAXParser_error) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg7 = Perl2XMLString(ST(6));
+ arg7 = UTF8_TRANSCODER->Perl2XMLString(ST(6));
}
ecode8 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(7), &val8);
@@ -63247,7 +38614,7 @@ XS(_wrap_SAXParser_error) {
{
(arg1)->error(arg2,(XMLCh const *)arg3,arg4,(XMLCh const *)arg5,(XMLCh const *)arg6,(XMLCh const *)arg7,arg8,arg9);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63310,7 +38677,7 @@ XS(_wrap_SAXParser_resetErrors) {
{
(arg1)->resetErrors();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63344,7 +38711,7 @@ XS(_wrap_delete_SAX2XMLReader) {
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63378,7 +38745,7 @@ XS(_wrap_SAX2XMLReader_getContentHandler) {
{
result = (XERCES_CPP_NAMESPACE::ContentHandler *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getContentHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | SWIG_SHADOW); argvi++ ;
@@ -63412,7 +38779,7 @@ XS(_wrap_SAX2XMLReader_getDTDHandler) {
{
result = (XERCES_CPP_NAMESPACE::DTDHandler *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getDTDHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler, 0 | SWIG_SHADOW); argvi++ ;
@@ -63448,7 +38815,7 @@ XS(_wrap_SAX2XMLReader_getFeature) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -63497,7 +38864,7 @@ XS(_wrap_SAX2XMLReader_getProperty) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -63551,7 +38918,7 @@ XS(_wrap_SAX2XMLReader_setContentHandler) {
{
(arg1)->setContentHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63594,7 +38961,7 @@ XS(_wrap_SAX2XMLReader_setDTDHandler) {
{
(arg1)->setDTDHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63637,7 +39004,7 @@ XS(_wrap_SAX2XMLReader_setEntityResolver) {
{
(arg1)->setEntityResolver(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63680,7 +39047,7 @@ XS(_wrap_SAX2XMLReader_setErrorHandler) {
{
(arg1)->setErrorHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63720,7 +39087,7 @@ XS(_wrap_SAX2XMLReader_setFeature) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -63776,7 +39143,7 @@ XS(_wrap_SAX2XMLReader_setProperty) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -63786,7 +39153,7 @@ XS(_wrap_SAX2XMLReader_setProperty) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
}
{
@@ -63855,7 +39222,7 @@ XS(_wrap_SAX2XMLReader_parse__SWIG_0) {
{
(arg1)->parse((XERCES_CPP_NAMESPACE::InputSource const &)*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -63892,7 +39259,7 @@ XS(_wrap_SAX2XMLReader_parse__SWIG_1) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -63900,7 +39267,7 @@ XS(_wrap_SAX2XMLReader_parse__SWIG_1) {
{
(arg1)->parse((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -64020,7 +39387,7 @@ XS(_wrap_SAX2XMLReader_getDeclarationHandler) {
{
result = (XERCES_CPP_NAMESPACE::DeclHandler *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getDeclarationHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, 0 | SWIG_SHADOW); argvi++ ;
@@ -64054,7 +39421,7 @@ XS(_wrap_SAX2XMLReader_getLexicalHandler) {
{
result = (XERCES_CPP_NAMESPACE::LexicalHandler *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getLexicalHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | SWIG_SHADOW); argvi++ ;
@@ -64095,7 +39462,7 @@ XS(_wrap_SAX2XMLReader_setDeclarationHandler) {
{
(arg1)->setDeclarationHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -64138,7 +39505,7 @@ XS(_wrap_SAX2XMLReader_setLexicalHandler) {
{
(arg1)->setLexicalHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -64174,7 +39541,7 @@ XS(_wrap_SAX2XMLReader_getValidator) {
{
result = (XERCES_CPP_NAMESPACE::XMLValidator *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getValidator();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator, 0 | SWIG_SHADOW); argvi++ ;
@@ -64208,7 +39575,7 @@ XS(_wrap_SAX2XMLReader_getErrorCount) {
{
result = (int)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getErrorCount();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
@@ -64242,7 +39609,7 @@ XS(_wrap_SAX2XMLReader_getExitOnFirstFatalError) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getExitOnFirstFatalError();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -64276,7 +39643,7 @@ XS(_wrap_SAX2XMLReader_getValidationConstraintFatal) {
{
result = (bool)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getValidationConstraintFatal();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -64312,7 +39679,7 @@ XS(_wrap_SAX2XMLReader_getGrammar) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -64320,7 +39687,7 @@ XS(_wrap_SAX2XMLReader_getGrammar) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getGrammar((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -64360,7 +39727,7 @@ XS(_wrap_SAX2XMLReader_getRootGrammar) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getRootGrammar();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -64402,10 +39769,10 @@ XS(_wrap_SAX2XMLReader_getURIText) {
{
result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getURIText(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
- ST(argvi) = XMLString2Perl(result);
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Perl(result);
++argvi;
@@ -64441,7 +39808,7 @@ XS(_wrap_SAX2XMLReader_getSrcOffset) {
{
result = (unsigned int)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getSrcOffset();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_unsigned_SS_int SWIG_PERL_CALL_ARGS_1(static_cast< unsigned int >(result)); argvi++ ;
@@ -64482,7 +39849,7 @@ XS(_wrap_SAX2XMLReader_setValidator) {
{
(arg1)->setValidator(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -64525,7 +39892,7 @@ XS(_wrap_SAX2XMLReader_setExitOnFirstFatalError) {
{
(arg1)->setExitOnFirstFatalError(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -64568,7 +39935,7 @@ XS(_wrap_SAX2XMLReader_setValidationConstraintFatal) {
{
(arg1)->setValidationConstraintFatal(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -64609,7 +39976,7 @@ XS(_wrap_SAX2XMLReader_parseFirst__SWIG_0) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, 0 );
@@ -64625,7 +39992,7 @@ XS(_wrap_SAX2XMLReader_parseFirst__SWIG_0) {
{
result = (bool)(arg1)->parseFirst((XMLCh const *)arg2,*arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -64687,7 +40054,7 @@ XS(_wrap_SAX2XMLReader_parseFirst__SWIG_1) {
{
result = (bool)(arg1)->parseFirst((char const *)arg2,*arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -64747,7 +40114,7 @@ XS(_wrap_SAX2XMLReader_parseFirst__SWIG_2) {
{
result = (bool)(arg1)->parseFirst((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,*arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -64934,7 +40301,7 @@ XS(_wrap_SAX2XMLReader_parseNext) {
{
result = (bool)(arg1)->parseNext(*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -64980,7 +40347,7 @@ XS(_wrap_SAX2XMLReader_parseReset) {
{
(arg1)->parseReset(*arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -65043,7 +40410,7 @@ XS(_wrap_SAX2XMLReader_loadGrammar__SWIG_0) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,arg3,arg4);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -65102,7 +40469,7 @@ XS(_wrap_SAX2XMLReader_loadGrammar__SWIG_1) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XERCES_CPP_NAMESPACE::InputSource const &)*arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -65148,7 +40515,7 @@ XS(_wrap_SAX2XMLReader_loadGrammar__SWIG_2) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -65166,7 +40533,7 @@ XS(_wrap_SAX2XMLReader_loadGrammar__SWIG_2) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3,arg4);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -65215,7 +40582,7 @@ XS(_wrap_SAX2XMLReader_loadGrammar__SWIG_3) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_short SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -65228,7 +40595,7 @@ XS(_wrap_SAX2XMLReader_loadGrammar__SWIG_3) {
{
result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar, SWIG_as_voidptrptr(&result)), 0 | SWIG_SHADOW); argvi++ ;
@@ -65473,7 +40840,7 @@ XS(_wrap_SAX2XMLReader_resetCachedGrammarPool) {
{
(arg1)->resetCachedGrammarPool();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -65514,7 +40881,7 @@ XS(_wrap_SAX2XMLReader_setInputBufferSize) {
{
(arg1)->setInputBufferSize(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -65557,7 +40924,7 @@ XS(_wrap_SAX2XMLReader_installAdvDocHandler) {
{
(arg1)->installAdvDocHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -65601,7 +40968,7 @@ XS(_wrap_SAX2XMLReader_removeAdvDocHandler) {
{
result = (bool)(arg1)->removeAdvDocHandler(arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
@@ -65650,7 +41017,7 @@ XS(_wrap_XMLReaderFactory_createXMLReader__SWIG_0) {
{
result = (XERCES_CPP_NAMESPACE::SAX2XMLReader *)XERCES_CPP_NAMESPACE::XMLReaderFactory::createXMLReader(arg1,arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
@@ -65689,7 +41056,7 @@ XS(_wrap_XMLReaderFactory_createXMLReader__SWIG_1) {
{
result = (XERCES_CPP_NAMESPACE::SAX2XMLReader *)XERCES_CPP_NAMESPACE::XMLReaderFactory::createXMLReader(arg1);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
@@ -65715,7 +41082,7 @@ XS(_wrap_XMLReaderFactory_createXMLReader__SWIG_2) {
{
result = (XERCES_CPP_NAMESPACE::SAX2XMLReader *)XERCES_CPP_NAMESPACE::XMLReaderFactory::createXMLReader();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
@@ -65826,7 +41193,7 @@ XS(_wrap_new_PerlCallbackHandler__SWIG_0) {
{
result = (PerlCallbackHandler *)new PerlCallbackHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
@@ -65854,7 +41221,7 @@ XS(_wrap_new_PerlCallbackHandler__SWIG_1) {
{
result = (PerlCallbackHandler *)new PerlCallbackHandler(arg1);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
@@ -65937,7 +41304,7 @@ XS(_wrap_delete_PerlCallbackHandler) {
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -65971,7 +41338,7 @@ XS(_wrap_PerlCallbackHandler_type) {
{
result = (int)(arg1)->type();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
@@ -66009,65 +41376,15 @@ XS(_wrap_PerlCallbackHandler_set_callback_obj) {
{
result = (SV *)(arg1)->set_callback_obj(arg2);
}
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = result; argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_PerlCallbackHandler_XMLString2Perl) {
- {
- PerlCallbackHandler *arg1 = (PerlCallbackHandler *) 0 ;
- XMLCh *arg2 = (XMLCh *) 0 ;
- SV *result = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: PerlCallbackHandler_XMLString2Perl(self,XMLCh const *);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_PerlCallbackHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlCallbackHandler_XMLString2Perl" "', argument " "1"" of type '" "PerlCallbackHandler *""'");
- }
- arg1 = reinterpret_cast< PerlCallbackHandler * >(argp1);
-
- if (ST(1) == &PL_sv_undef) {
- SWIG_Perl_NullRef("perl-string",2,"PerlCallbackHandler_XMLString2Perl");
- goto fail;
- } else {
- // we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
- }
-
- {
- try
- {
- result = (SV *)(arg1)->XMLString2Perl((XMLCh const *)arg2);
- }
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = result; argvi++ ;
- delete[] arg2;
-
XSRETURN(argvi);
fail:
- delete[] arg2;
-
SWIG_croak_null();
}
}
@@ -66087,7 +41404,7 @@ XS(_wrap_new_PerlErrorCallbackHandler__SWIG_0) {
{
result = (PerlErrorCallbackHandler *)new PerlErrorCallbackHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlErrorCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
@@ -66115,7 +41432,7 @@ XS(_wrap_new_PerlErrorCallbackHandler__SWIG_1) {
{
result = (PerlErrorCallbackHandler *)new PerlErrorCallbackHandler(arg1);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlErrorCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
@@ -66198,7 +41515,7 @@ XS(_wrap_delete_PerlErrorCallbackHandler) {
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -66232,7 +41549,7 @@ XS(_wrap_PerlErrorCallbackHandler_type) {
{
result = (int)(arg1)->type();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
@@ -66265,7 +41582,7 @@ XS(_wrap_PerlErrorCallbackHandler_resetErrors) {
{
(arg1)->resetErrors();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -66291,7 +41608,7 @@ XS(_wrap_new_PerlEntityResolverHandler__SWIG_0) {
{
result = (PerlEntityResolverHandler *)new PerlEntityResolverHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlEntityResolverHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
@@ -66319,7 +41636,7 @@ XS(_wrap_new_PerlEntityResolverHandler__SWIG_1) {
{
result = (PerlEntityResolverHandler *)new PerlEntityResolverHandler(arg1);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlEntityResolverHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
@@ -66402,7 +41719,7 @@ XS(_wrap_delete_PerlEntityResolverHandler) {
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -66436,178 +41753,7 @@ XS(_wrap_PerlEntityResolverHandler_type) {
{
result = (int)(arg1)->type();
}
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_PerlNodeFilterCallbackHandler__SWIG_0) {
- {
- PerlNodeFilterCallbackHandler *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 0) || (items > 0)) {
- SWIG_croak("Usage: new_PerlNodeFilterCallbackHandler();");
- }
- {
- try
- {
- result = (PerlNodeFilterCallbackHandler *)new PerlNodeFilterCallbackHandler();
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlNodeFilterCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
- XSRETURN(argvi);
- fail:
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_PerlNodeFilterCallbackHandler__SWIG_1) {
- {
- SV *arg1 = (SV *) 0 ;
- PerlNodeFilterCallbackHandler *result = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: new_PerlNodeFilterCallbackHandler(obj);");
- }
- {
- arg1 = ST(0);
- }
- {
- try
- {
- result = (PerlNodeFilterCallbackHandler *)new PerlNodeFilterCallbackHandler(arg1);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlNodeFilterCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_new_PerlNodeFilterCallbackHandler) {
- dXSARGS;
-
- {
- unsigned long _index = 0;
- SWIG_TypeRank _rank = 0;
- if (items == 0) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 1;
- if (_rank == _rankm) goto dispatch;
- }
- }
- if (items == 1) {
- SWIG_TypeRank _ranki = 0;
- SWIG_TypeRank _rankm = 0;
- SWIG_TypeRank _pi = 1;
- int _v = 0;
- {
- {
- _v = SvOK(ST(0)) ? 1 : 0;
- }
- }
- if (!_v) goto check_2;
- _ranki += _v*_pi;
- _rankm += _pi;
- _pi *= SWIG_MAXCASTRANK;
- if (!_index || (_ranki < _rank)) {
- _rank = _ranki; _index = 2;
- if (_rank == _rankm) goto dispatch;
- }
- }
- check_2:
-
- dispatch:
- switch(_index) {
- case 1:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_PerlNodeFilterCallbackHandler__SWIG_0); return;
- case 2:
- ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_PerlNodeFilterCallbackHandler__SWIG_1); return;
- }
- }
-
- croak("No matching function for overloaded 'new_PerlNodeFilterCallbackHandler'");
- XSRETURN(0);
-}
-
-
-XS(_wrap_delete_PerlNodeFilterCallbackHandler) {
- {
- PerlNodeFilterCallbackHandler *arg1 = (PerlNodeFilterCallbackHandler *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: delete_PerlNodeFilterCallbackHandler(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_PerlNodeFilterCallbackHandler, SWIG_POINTER_DISOWN | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PerlNodeFilterCallbackHandler" "', argument " "1"" of type '" "PerlNodeFilterCallbackHandler *""'");
- }
- arg1 = reinterpret_cast< PerlNodeFilterCallbackHandler * >(argp1);
- {
- try
- {
- delete arg1;
-
- }
- CATCH_DOM_EXCEPTION
- }
-
-
- XSRETURN(argvi);
- fail:
-
- SWIG_croak_null();
- }
-}
-
-
-XS(_wrap_PerlNodeFilterCallbackHandler_type) {
- {
- PerlNodeFilterCallbackHandler *arg1 = (PerlNodeFilterCallbackHandler *) 0 ;
- int result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 1) || (items > 1)) {
- SWIG_croak("Usage: PerlNodeFilterCallbackHandler_type(self);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_PerlNodeFilterCallbackHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlNodeFilterCallbackHandler_type" "', argument " "1"" of type '" "PerlNodeFilterCallbackHandler *""'");
- }
- arg1 = reinterpret_cast< PerlNodeFilterCallbackHandler * >(argp1);
- {
- try
- {
- result = (int)(arg1)->type();
- }
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
@@ -66619,50 +41765,6 @@ XS(_wrap_PerlNodeFilterCallbackHandler_type) {
}
-XS(_wrap_PerlNodeFilterCallbackHandler_acceptNode) {
- {
- PerlNodeFilterCallbackHandler *arg1 = (PerlNodeFilterCallbackHandler *) 0 ;
- XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
- short result;
- void *argp1 = 0 ;
- int res1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int argvi = 0;
- dXSARGS;
-
- if ((items < 2) || (items > 2)) {
- SWIG_croak("Usage: PerlNodeFilterCallbackHandler_acceptNode(self,node);");
- }
- res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_PerlNodeFilterCallbackHandler, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlNodeFilterCallbackHandler_acceptNode" "', argument " "1"" of type '" "PerlNodeFilterCallbackHandler const *""'");
- }
- arg1 = reinterpret_cast< PerlNodeFilterCallbackHandler * >(argp1);
- res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PerlNodeFilterCallbackHandler_acceptNode" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DOMNode const *""'");
- }
- arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DOMNode * >(argp2);
- {
- try
- {
- result = (short)((PerlNodeFilterCallbackHandler const *)arg1)->acceptNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
- }
- CATCH_DOM_EXCEPTION
- }
- ST(argvi) = SWIG_From_short SWIG_PERL_CALL_ARGS_1(static_cast< short >(result)); argvi++ ;
-
-
- XSRETURN(argvi);
- fail:
-
-
- SWIG_croak_null();
- }
-}
-
-
XS(_wrap_new_PerlDocumentCallbackHandler__SWIG_0) {
{
PerlDocumentCallbackHandler *result = 0 ;
@@ -66677,7 +41779,7 @@ XS(_wrap_new_PerlDocumentCallbackHandler__SWIG_0) {
{
result = (PerlDocumentCallbackHandler *)new PerlDocumentCallbackHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlDocumentCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
@@ -66705,7 +41807,7 @@ XS(_wrap_new_PerlDocumentCallbackHandler__SWIG_1) {
{
result = (PerlDocumentCallbackHandler *)new PerlDocumentCallbackHandler(arg1);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlDocumentCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
@@ -66788,7 +41890,7 @@ XS(_wrap_delete_PerlDocumentCallbackHandler) {
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -66822,7 +41924,7 @@ XS(_wrap_PerlDocumentCallbackHandler_type) {
{
result = (int)(arg1)->type();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
@@ -66860,7 +41962,7 @@ XS(_wrap_PerlDocumentCallbackHandler_characters) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -66873,7 +41975,7 @@ XS(_wrap_PerlDocumentCallbackHandler_characters) {
{
(arg1)->characters((XMLCh const *)arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -66917,7 +42019,7 @@ XS(_wrap_PerlDocumentCallbackHandler_processingInstruction) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -66926,7 +42028,7 @@ XS(_wrap_PerlDocumentCallbackHandler_processingInstruction) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -66934,7 +42036,7 @@ XS(_wrap_PerlDocumentCallbackHandler_processingInstruction) {
{
(arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -66987,7 +42089,7 @@ XS(_wrap_PerlDocumentCallbackHandler_setDocumentLocator) {
{
(arg1)->setDocumentLocator((XERCES_CPP_NAMESPACE::Locator const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -67015,7 +42117,7 @@ XS(_wrap_new_PerlContentCallbackHandler__SWIG_0) {
{
result = (PerlContentCallbackHandler *)new PerlContentCallbackHandler();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlContentCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
XSRETURN(argvi);
@@ -67043,7 +42145,7 @@ XS(_wrap_new_PerlContentCallbackHandler__SWIG_1) {
{
result = (PerlContentCallbackHandler *)new PerlContentCallbackHandler(arg1);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PerlContentCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
@@ -67126,7 +42228,7 @@ XS(_wrap_delete_PerlContentCallbackHandler) {
delete arg1;
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -67160,7 +42262,7 @@ XS(_wrap_PerlContentCallbackHandler_type) {
{
result = (int)(arg1)->type();
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
@@ -67198,7 +42300,7 @@ XS(_wrap_PerlContentCallbackHandler_characters) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
ecode3 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
@@ -67211,7 +42313,7 @@ XS(_wrap_PerlContentCallbackHandler_characters) {
{
(arg1)->characters((XMLCh const *)arg2,arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -67255,7 +42357,7 @@ XS(_wrap_PerlContentCallbackHandler_processingInstruction) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -67264,7 +42366,7 @@ XS(_wrap_PerlContentCallbackHandler_processingInstruction) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -67272,7 +42374,7 @@ XS(_wrap_PerlContentCallbackHandler_processingInstruction) {
{
(arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -67325,7 +42427,7 @@ XS(_wrap_PerlContentCallbackHandler_setDocumentLocator) {
{
(arg1)->setDocumentLocator((XERCES_CPP_NAMESPACE::Locator const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -67363,7 +42465,7 @@ XS(_wrap_PerlContentCallbackHandler_startPrefixMapping) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
@@ -67372,7 +42474,7 @@ XS(_wrap_PerlContentCallbackHandler_startPrefixMapping) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg3 = Perl2XMLString(ST(2));
+ arg3 = UTF8_TRANSCODER->Perl2XMLString(ST(2));
}
{
@@ -67380,7 +42482,7 @@ XS(_wrap_PerlContentCallbackHandler_startPrefixMapping) {
{
(arg1)->startPrefixMapping((XMLCh const *)arg2,(XMLCh const *)arg3);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -67427,7 +42529,7 @@ XS(_wrap_PerlContentCallbackHandler_endPrefixMapping) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -67435,7 +42537,7 @@ XS(_wrap_PerlContentCallbackHandler_endPrefixMapping) {
{
(arg1)->endPrefixMapping((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -67476,7 +42578,7 @@ XS(_wrap_PerlContentCallbackHandler_skippedEntity) {
goto fail;
} else {
// we convert *everything* into a string that isn't undef
- arg2 = Perl2XMLString(ST(1));
+ arg2 = UTF8_TRANSCODER->Perl2XMLString(ST(1));
}
{
@@ -67484,7 +42586,7 @@ XS(_wrap_PerlContentCallbackHandler_skippedEntity) {
{
(arg1)->skippedEntity((XMLCh const *)arg2);
}
- CATCH_DOM_EXCEPTION
+ CATCH_XML_EXCEPTION
}
@@ -67505,39 +42607,129 @@ XS(_wrap_PerlContentCallbackHandler_skippedEntity) {
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
-static void *_p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMText(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMText *) ((XERCES_CPP_NAMESPACE::DOMCDATASection *) x));
+static void *_p_XERCES_CPP_NAMESPACE__DTDAttDefListTo_p_XERCES_CPP_NAMESPACE__XMLAttDefList(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLAttDefList *) ((XERCES_CPP_NAMESPACE::DTDAttDefList *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__Wrapper4InputSourceTo_p_XERCES_CPP_NAMESPACE__DOMLSInput(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMLSInput *) ((XERCES_CPP_NAMESPACE::Wrapper4InputSource *) x));
+static void *_p_XERCES_CPP_NAMESPACE__SchemaAttDefListTo_p_XERCES_CPP_NAMESPACE__XMLAttDefList(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLAttDefList *) ((XERCES_CPP_NAMESPACE::SchemaAttDefList *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLEnumerator<XERCES_CPP_NAMESPACE::DTDElementDecl > *) ((XERCES_CPP_NAMESPACE::NameIdPoolEnumerator<XERCES_CPP_NAMESPACE::DTDElementDecl > *) x));
+static void *_p_XERCES_CPP_NAMESPACE__DTDElementDeclTo_p_XERCES_CPP_NAMESPACE__XMLElementDecl(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLElementDecl *) ((XERCES_CPP_NAMESPACE::DTDElementDecl *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_tTo_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLEnumerator<XERCES_CPP_NAMESPACE::DTDEntityDecl > *) ((XERCES_CPP_NAMESPACE::NameIdPoolEnumerator<XERCES_CPP_NAMESPACE::DTDEntityDecl > *) x));
+static void *_p_XERCES_CPP_NAMESPACE__SchemaElementDeclTo_p_XERCES_CPP_NAMESPACE__XMLElementDecl(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLElementDecl *) ((XERCES_CPP_NAMESPACE::SchemaElementDecl *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLEnumerator<XERCES_CPP_NAMESPACE::SchemaElementDecl > *) ((XERCES_CPP_NAMESPACE::RefHash3KeysIdPoolEnumerator<XERCES_CPP_NAMESPACE::SchemaElementDecl > *) x));
+static void *_p_XERCES_CPP_NAMESPACE__SAXNotSupportedExceptionTo_p_XERCES_CPP_NAMESPACE__SAXException(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::SAXException *) ((XERCES_CPP_NAMESPACE::SAXNotSupportedException *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__DOMImplementationTo_p_XERCES_CPP_NAMESPACE__DOMImplementationLS(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMImplementationLS *) ((XERCES_CPP_NAMESPACE::DOMImplementation *) x));
+static void *_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedExceptionTo_p_XERCES_CPP_NAMESPACE__SAXException(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::SAXException *) ((XERCES_CPP_NAMESPACE::SAXNotRecognizedException *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__DTDValidatorTo_p_XERCES_CPP_NAMESPACE__XMLValidator(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLValidator *) ((XERCES_CPP_NAMESPACE::DTDValidator *) x));
+static void *_p_XERCES_CPP_NAMESPACE__SAXParseExceptionTo_p_XERCES_CPP_NAMESPACE__SAXException(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::SAXException *) ((XERCES_CPP_NAMESPACE::SAXParseException *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__SchemaValidatorTo_p_XERCES_CPP_NAMESPACE__XMLValidator(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLValidator *) ((XERCES_CPP_NAMESPACE::SchemaValidator *) x));
+static void *_p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XMLErrorReporter(void *x) {
+ return (void *)((XMLErrorReporter *) ((XERCES_CPP_NAMESPACE::SAXParser *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SchemaAttDefTo_p_XERCES_CPP_NAMESPACE__XMLAttDef(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLAttDef *) ((XERCES_CPP_NAMESPACE::SchemaAttDef *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DTDAttDefTo_p_XERCES_CPP_NAMESPACE__XMLAttDef(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLAttDef *) ((XERCES_CPP_NAMESPACE::DTDAttDef *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__EntityResolver(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::EntityResolver *) ((XERCES_CPP_NAMESPACE::HandlerBase *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__EntityResolver(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::EntityResolver *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
+}
+static void *_p_PerlEntityResolverHandlerTo_p_XERCES_CPP_NAMESPACE__EntityResolver(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::EntityResolver *) ((PerlEntityResolverHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__DTDHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DTDHandler *) ((XERCES_CPP_NAMESPACE::HandlerBase *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__DTDHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DTDHandler *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__DocumentHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DocumentHandler *) ((XERCES_CPP_NAMESPACE::HandlerBase *) x));
+}
+static void *_p_PerlDocumentCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__DocumentHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DocumentHandler *) ((PerlDocumentCallbackHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__ErrorHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::ErrorHandler *) ((XERCES_CPP_NAMESPACE::HandlerBase *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__ErrorHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::ErrorHandler *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
+}
+static void *_p_PerlErrorCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__ErrorHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::ErrorHandler *) ((PerlErrorCallbackHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__ContentHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::ContentHandler *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
+}
+static void *_p_PerlContentCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__ContentHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::ContentHandler *) ((PerlContentCallbackHandler *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilterTo_p_XERCES_CPP_NAMESPACE__DOMNodeFilter(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNodeFilter *) ((XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *) x));
+static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__LexicalHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::LexicalHandler *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__DeclHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DeclHandler *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
+}
+static void *_p_PerlErrorCallbackHandlerTo_p_PerlCallbackHandler(void *x) {
+ return (void *)((PerlCallbackHandler *) ((PerlErrorCallbackHandler *) x));
+}
+static void *_p_PerlEntityResolverHandlerTo_p_PerlCallbackHandler(void *x) {
+ return (void *)((PerlCallbackHandler *) ((PerlEntityResolverHandler *) x));
}
-static void *_p_PerlNodeFilterCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__DOMNodeFilter(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNodeFilter *) ((PerlNodeFilterCallbackHandler *) x));
+static void *_p_PerlDocumentCallbackHandlerTo_p_PerlCallbackHandler(void *x) {
+ return (void *)((PerlCallbackHandler *) ((PerlDocumentCallbackHandler *) x));
+}
+static void *_p_PerlContentCallbackHandlerTo_p_PerlCallbackHandler(void *x) {
+ return (void *)((PerlCallbackHandler *) ((PerlContentCallbackHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLDTDDescriptionTo_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLGrammarDescription *) ((XERCES_CPP_NAMESPACE::XMLDTDDescription *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__XMLSchemaDescriptionTo_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLGrammarDescription *) ((XERCES_CPP_NAMESPACE::XMLSchemaDescription *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DTDEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMLEntityDecl(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLEntityDecl *) ((XERCES_CPP_NAMESPACE::DTDEntityDecl *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__LocalFileInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::LocalFileInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__StdInInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::StdInInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__URLInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::URLInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__MemBufInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::MemBufInputSource *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DTDGrammarTo_p_XERCES_CPP_NAMESPACE__Grammar(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::Grammar *) ((XERCES_CPP_NAMESPACE::DTDGrammar *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SchemaGrammarTo_p_XERCES_CPP_NAMESPACE__Grammar(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::Grammar *) ((XERCES_CPP_NAMESPACE::SchemaGrammar *) x));
}
static void *_p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XERCES_CPP_NAMESPACE__Parser(void *x) {
return (void *)((XERCES_CPP_NAMESPACE::Parser *) ((XERCES_CPP_NAMESPACE::SAXParser *) x));
}
+static void *_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLEnumerator<XERCES_CPP_NAMESPACE::SchemaElementDecl > *) ((XERCES_CPP_NAMESPACE::RefHash3KeysIdPoolEnumerator<XERCES_CPP_NAMESPACE::SchemaElementDecl > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_tTo_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLEnumerator<XERCES_CPP_NAMESPACE::DTDEntityDecl > *) ((XERCES_CPP_NAMESPACE::NameIdPoolEnumerator<XERCES_CPP_NAMESPACE::DTDEntityDecl > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLEnumerator<XERCES_CPP_NAMESPACE::DTDElementDecl > *) ((XERCES_CPP_NAMESPACE::NameIdPoolEnumerator<XERCES_CPP_NAMESPACE::DTDElementDecl > *) x));
+}
static void *_p_XERCES_CPP_NAMESPACE__XMLSchemaDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLGrammarDescription *) ((XERCES_CPP_NAMESPACE::XMLSchemaDescription *) x));
}
@@ -67583,18 +42775,6 @@ static void *_p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XERCES_CPP_NAMESPACE__XMemor
static void *_p_XERCES_CPP_NAMESPACE__XMLNotationDeclTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLNotationDecl *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__XMLFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLFormatTarget *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__StdOutFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::StdOutFormatTarget *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__LocalFileFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::LocalFileFormatTarget *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__MemBufFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::MemBufFormatTarget *) x));
-}
static void *_p_XERCES_CPP_NAMESPACE__XMLURLTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLURL *) x));
}
@@ -67616,12 +42796,6 @@ static void *_p_XERCES_CPP_NAMESPACE__MemBufInputSourceTo_p_XERCES_CPP_NAMESPACE
static void *_p_XERCES_CPP_NAMESPACE__SchemaAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLAttDef *) ((XERCES_CPP_NAMESPACE::SchemaAttDef *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__AbstractDOMParserTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::AbstractDOMParser *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::AbstractDOMParser *) ((XERCES_CPP_NAMESPACE::XercesDOMParser *) x));
-}
static void *_p_XERCES_CPP_NAMESPACE__XMLExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLException *) x));
}
@@ -67679,221 +42853,17 @@ static void *_p_XERCES_CPP_NAMESPACE__XMLAttDefListTo_p_XERCES_CPP_NAMESPACE__XM
static void *_p_XERCES_CPP_NAMESPACE__XMLUriTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLUri *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInputTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__XMLFormatterTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLFormatter *) x));
-}
static void *_p_XERCES_CPP_NAMESPACE__DTDEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::XMLEntityDecl *) ((XERCES_CPP_NAMESPACE::DTDEntityDecl *) x));
}
static void *_p_XERCES_CPP_NAMESPACE__XMLEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLEntityDecl *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XMLErrorReporter(void *x) {
- return (void *)((XMLErrorReporter *) ((XERCES_CPP_NAMESPACE::SAXParser *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__AbstractDOMParserTo_p_XMLErrorReporter(void *x) {
- return (void *)((XMLErrorReporter *) ((XERCES_CPP_NAMESPACE::AbstractDOMParser *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DTDElementDeclTo_p_XERCES_CPP_NAMESPACE__XMLElementDecl(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLElementDecl *) ((XERCES_CPP_NAMESPACE::DTDElementDecl *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__SchemaElementDeclTo_p_XERCES_CPP_NAMESPACE__XMLElementDecl(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLElementDecl *) ((XERCES_CPP_NAMESPACE::SchemaElementDecl *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__AbstractDOMParser(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::AbstractDOMParser *) ((XERCES_CPP_NAMESPACE::XercesDOMParser *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__XMLDTDDescriptionTo_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLGrammarDescription *) ((XERCES_CPP_NAMESPACE::XMLDTDDescription *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__XMLSchemaDescriptionTo_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLGrammarDescription *) ((XERCES_CPP_NAMESPACE::XMLSchemaDescription *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DTDGrammarTo_p_XERCES_CPP_NAMESPACE__Grammar(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::Grammar *) ((XERCES_CPP_NAMESPACE::DTDGrammar *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__SchemaGrammarTo_p_XERCES_CPP_NAMESPACE__Grammar(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::Grammar *) ((XERCES_CPP_NAMESPACE::SchemaGrammar *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__SchemaAttDefTo_p_XERCES_CPP_NAMESPACE__XMLAttDef(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLAttDef *) ((XERCES_CPP_NAMESPACE::SchemaAttDef *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DTDAttDefTo_p_XERCES_CPP_NAMESPACE__XMLAttDef(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLAttDef *) ((XERCES_CPP_NAMESPACE::DTDAttDef *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__StdOutFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::StdOutFormatTarget *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__LocalFileFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::LocalFileFormatTarget *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__MemBufFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLFormatTarget *) ((XERCES_CPP_NAMESPACE::MemBufFormatTarget *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__LocalFileInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::LocalFileInputSource *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__StdInInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::StdInInputSource *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__URLInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::URLInputSource *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__MemBufInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::MemBufInputSource *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInputTo_p_XERCES_CPP_NAMESPACE__InputSource(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::InputSource *) ((XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DTDAttDefListTo_p_XERCES_CPP_NAMESPACE__XMLAttDefList(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLAttDefList *) ((XERCES_CPP_NAMESPACE::DTDAttDefList *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__SchemaAttDefListTo_p_XERCES_CPP_NAMESPACE__XMLAttDefList(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLAttDefList *) ((XERCES_CPP_NAMESPACE::SchemaAttDefList *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__AbstractDOMParserTo_p_XERCES_CPP_NAMESPACE__PSVIHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::PSVIHandler *) ((XERCES_CPP_NAMESPACE::AbstractDOMParser *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__PSVIHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::PSVIHandler *) (XERCES_CPP_NAMESPACE::AbstractDOMParser *) ((XERCES_CPP_NAMESPACE::XercesDOMParser *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__DeclHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DeclHandler *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__LexicalHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::LexicalHandler *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__ContentHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::ContentHandler *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
-}
-static void *_p_PerlContentCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__ContentHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::ContentHandler *) ((PerlContentCallbackHandler *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__ErrorHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::ErrorHandler *) ((XERCES_CPP_NAMESPACE::HandlerBase *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__ErrorHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::ErrorHandler *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
-}
-static void *_p_PerlErrorCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__ErrorHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::ErrorHandler *) ((PerlErrorCallbackHandler *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__DocumentHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DocumentHandler *) ((XERCES_CPP_NAMESPACE::HandlerBase *) x));
-}
-static void *_p_PerlDocumentCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__DocumentHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DocumentHandler *) ((PerlDocumentCallbackHandler *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__DTDHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DTDHandler *) ((XERCES_CPP_NAMESPACE::HandlerBase *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__DTDHandler(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DTDHandler *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
-}
-static void *_p_PerlErrorCallbackHandlerTo_p_PerlCallbackHandler(void *x) {
- return (void *)((PerlCallbackHandler *) ((PerlErrorCallbackHandler *) x));
-}
-static void *_p_PerlEntityResolverHandlerTo_p_PerlCallbackHandler(void *x) {
- return (void *)((PerlCallbackHandler *) ((PerlEntityResolverHandler *) x));
-}
-static void *_p_PerlNodeFilterCallbackHandlerTo_p_PerlCallbackHandler(void *x) {
- return (void *)((PerlCallbackHandler *) ((PerlNodeFilterCallbackHandler *) x));
-}
-static void *_p_PerlDocumentCallbackHandlerTo_p_PerlCallbackHandler(void *x) {
- return (void *)((PerlCallbackHandler *) ((PerlDocumentCallbackHandler *) x));
-}
-static void *_p_PerlContentCallbackHandlerTo_p_PerlCallbackHandler(void *x) {
- return (void *)((PerlCallbackHandler *) ((PerlContentCallbackHandler *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__SAXNotSupportedExceptionTo_p_XERCES_CPP_NAMESPACE__SAXException(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::SAXException *) ((XERCES_CPP_NAMESPACE::SAXNotSupportedException *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedExceptionTo_p_XERCES_CPP_NAMESPACE__SAXException(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::SAXException *) ((XERCES_CPP_NAMESPACE::SAXNotRecognizedException *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__SAXParseExceptionTo_p_XERCES_CPP_NAMESPACE__SAXException(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::SAXException *) ((XERCES_CPP_NAMESPACE::SAXParseException *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMRangeExceptionTo_p_XERCES_CPP_NAMESPACE__DOMException(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMException *) ((XERCES_CPP_NAMESPACE::DOMRangeException *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMLSExceptionTo_p_XERCES_CPP_NAMESPACE__DOMException(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMException *) ((XERCES_CPP_NAMESPACE::DOMLSException *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DTDEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMLEntityDecl(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::XMLEntityDecl *) ((XERCES_CPP_NAMESPACE::DTDEntityDecl *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMAttrTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMAttr *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMNotationTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMNotation *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) (XERCES_CPP_NAMESPACE::DOMCharacterData *) ((XERCES_CPP_NAMESPACE::DOMText *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentFragmentTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMDocumentFragment *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMXPathNamespaceTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMXPathNamespace *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) (XERCES_CPP_NAMESPACE::DOMCharacterData *)(XERCES_CPP_NAMESPACE::DOMText *) ((XERCES_CPP_NAMESPACE::DOMCDATASection *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMEntityReferenceTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMEntityReference *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMEntityTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMEntity *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMCharacterDataTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMCharacterData *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentTypeTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMDocumentType *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) (XERCES_CPP_NAMESPACE::DOMCharacterData *) ((XERCES_CPP_NAMESPACE::DOMComment *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMDocument *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMElementTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMElement *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMProcessingInstructionTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) ((XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMDocumentRange(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMDocumentRange *) ((XERCES_CPP_NAMESPACE::DOMDocument *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMDocumentTraversal *) ((XERCES_CPP_NAMESPACE::DOMDocument *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__EntityResolver(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::EntityResolver *) ((XERCES_CPP_NAMESPACE::HandlerBase *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__EntityResolver(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::EntityResolver *) ((XERCES_CPP_NAMESPACE::DefaultHandler *) x));
-}
-static void *_p_PerlEntityResolverHandlerTo_p_XERCES_CPP_NAMESPACE__EntityResolver(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::EntityResolver *) ((PerlEntityResolverHandler *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMCharacterData *) ((XERCES_CPP_NAMESPACE::DOMText *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMCharacterData *) ((XERCES_CPP_NAMESPACE::DOMComment *) x));
-}
-static void *_p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMCharacterData *) (XERCES_CPP_NAMESPACE::DOMText *) ((XERCES_CPP_NAMESPACE::DOMCDATASection *) x));
+static void *_p_XERCES_CPP_NAMESPACE__DTDValidatorTo_p_XERCES_CPP_NAMESPACE__XMLValidator(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLValidator *) ((XERCES_CPP_NAMESPACE::DTDValidator *) x));
}
-static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator(void *x) {
- return (void *)((XERCES_CPP_NAMESPACE::DOMXPathEvaluator *) ((XERCES_CPP_NAMESPACE::DOMDocument *) x));
+static void *_p_XERCES_CPP_NAMESPACE__SchemaValidatorTo_p_XERCES_CPP_NAMESPACE__XMLValidator(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLValidator *) ((XERCES_CPP_NAMESPACE::SchemaValidator *) x));
}
static swig_type_info _swigt__p_DatatypeValidatorFactory = {"_p_DatatypeValidatorFactory", "DatatypeValidatorFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IdentityConstraint = {"_p_IdentityConstraint", "IdentityConstraint *", 0, 0, (void*)0, 0};
@@ -67907,7 +42877,6 @@ static swig_type_info _swigt__p_PerlContentCallbackHandler = {"_p_PerlContentCal
static swig_type_info _swigt__p_PerlDocumentCallbackHandler = {"_p_PerlDocumentCallbackHandler", "PerlDocumentCallbackHandler *", 0, 0, (void*)"XML::Xerces::PerlDocumentCallbackHandler", 0};
static swig_type_info _swigt__p_PerlEntityResolverHandler = {"_p_PerlEntityResolverHandler", "PerlEntityResolverHandler *", 0, 0, (void*)"XML::Xerces::PerlEntityResolverHandler", 0};
static swig_type_info _swigt__p_PerlErrorCallbackHandler = {"_p_PerlErrorCallbackHandler", "PerlErrorCallbackHandler *", 0, 0, (void*)"XML::Xerces::PerlErrorCallbackHandler", 0};
-static swig_type_info _swigt__p_PerlNodeFilterCallbackHandler = {"_p_PerlNodeFilterCallbackHandler", "PerlNodeFilterCallbackHandler *", 0, 0, (void*)"XML::Xerces::PerlNodeFilterCallbackHandler", 0};
static swig_type_info _swigt__p_RefArrayVectorOfTuint16_t_t = {"_p_RefArrayVectorOfTuint16_t_t", "RefArrayVectorOf<uint16_t > *|RefArrayVectorOf<XMLCh > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RefHash2KeysTableOfTValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t_t = {"_p_RefHash2KeysTableOfTValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t_t", "RefHash2KeysTableOf<ValueVectorOf<XERCES_CPP_NAMESPACE::SchemaElementDecl * > > *|RefHash2KeysTableOf<XERCES_CPP_NAMESPACE::ElemVector > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RefHashTableOfTXERCES_CPP_NAMESPACE__ComplexTypeInfo_t = {"_p_RefHashTableOfTXERCES_CPP_NAMESPACE__ComplexTypeInfo_t", "RefHashTableOf<XERCES_CPP_NAMESPACE::ComplexTypeInfo > *", 0, 0, (void*)0, 0};
@@ -67919,64 +42888,12 @@ static swig_type_info _swigt__p_SecurityManager = {"_p_SecurityManager", "Securi
static swig_type_info _swigt__p_ValidationContext = {"_p_ValidationContext", "ValidationContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t = {"_p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t", "ValueVectorOf<XERCES_CPP_NAMESPACE::SchemaElementDecl * > *|XERCES_CPP_NAMESPACE::ElemVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ValueVectorOfTunsigned_int_t = {"_p_ValueVectorOfTunsigned_int_t", "ValueVectorOf<unsigned int > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__AbstractDOMParser = {"_p_XERCES_CPP_NAMESPACE__AbstractDOMParser", "XERCES_CPP_NAMESPACE::AbstractDOMParser *", 0, 0, (void*)"XML::Xerces::AbstractDOMParser", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__AttributeList = {"_p_XERCES_CPP_NAMESPACE__AttributeList", "XERCES_CPP_NAMESPACE::AttributeList *", 0, 0, (void*)"XML::Xerces::AttributeList", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__Attributes = {"_p_XERCES_CPP_NAMESPACE__Attributes", "XERCES_CPP_NAMESPACE::Attributes *", 0, 0, (void*)"XML::Xerces::Attributes", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__BinInputStream = {"_p_XERCES_CPP_NAMESPACE__BinInputStream", "XERCES_CPP_NAMESPACE::BinInputStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__ComplexTypeInfo = {"_p_XERCES_CPP_NAMESPACE__ComplexTypeInfo", "XERCES_CPP_NAMESPACE::ComplexTypeInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__ContentHandler = {"_p_XERCES_CPP_NAMESPACE__ContentHandler", "XERCES_CPP_NAMESPACE::ContentHandler *", 0, 0, (void*)"XML::Xerces::ContentHandler", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__ContentSpecNode = {"_p_XERCES_CPP_NAMESPACE__ContentSpecNode", "XERCES_CPP_NAMESPACE::ContentSpecNode *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMAttr = {"_p_XERCES_CPP_NAMESPACE__DOMAttr", "XERCES_CPP_NAMESPACE::DOMAttr *", 0, 0, (void*)"XML::Xerces::DOMAttr", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection = {"_p_XERCES_CPP_NAMESPACE__DOMCDATASection", "XERCES_CPP_NAMESPACE::DOMCDATASection *", 0, 0, (void*)"XML::Xerces::DOMCDATASection", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData = {"_p_XERCES_CPP_NAMESPACE__DOMCharacterData", "XERCES_CPP_NAMESPACE::DOMCharacterData *", 0, 0, (void*)"XML::Xerces::DOMCharacterData", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMComment = {"_p_XERCES_CPP_NAMESPACE__DOMComment", "XERCES_CPP_NAMESPACE::DOMComment *", 0, 0, (void*)"XML::Xerces::DOMComment", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMConfiguration = {"_p_XERCES_CPP_NAMESPACE__DOMConfiguration", "XERCES_CPP_NAMESPACE::DOMConfiguration *", 0, 0, (void*)"XML::Xerces::DOMConfiguration", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocument = {"_p_XERCES_CPP_NAMESPACE__DOMDocument", "XERCES_CPP_NAMESPACE::DOMDocument *", 0, 0, (void*)"XML::Xerces::DOMDocument", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment = {"_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment", "XERCES_CPP_NAMESPACE::DOMDocumentFragment *", 0, 0, (void*)"XML::Xerces::DOMDocumentFragment", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentRange = {"_p_XERCES_CPP_NAMESPACE__DOMDocumentRange", "XERCES_CPP_NAMESPACE::DOMDocumentRange *", 0, 0, (void*)"XML::Xerces::DOMDocumentRange", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal = {"_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal", "XERCES_CPP_NAMESPACE::DOMDocumentTraversal *", 0, 0, (void*)"XML::Xerces::DOMDocumentTraversal", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType = {"_p_XERCES_CPP_NAMESPACE__DOMDocumentType", "XERCES_CPP_NAMESPACE::DOMDocumentType *", 0, 0, (void*)"XML::Xerces::DOMDocumentType", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMElement = {"_p_XERCES_CPP_NAMESPACE__DOMElement", "XERCES_CPP_NAMESPACE::DOMElement *", 0, 0, (void*)"XML::Xerces::DOMElement", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMEntity = {"_p_XERCES_CPP_NAMESPACE__DOMEntity", "XERCES_CPP_NAMESPACE::DOMEntity *", 0, 0, (void*)"XML::Xerces::DOMEntity", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference = {"_p_XERCES_CPP_NAMESPACE__DOMEntityReference", "XERCES_CPP_NAMESPACE::DOMEntityReference *", 0, 0, (void*)"XML::Xerces::DOMEntityReference", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMError = {"_p_XERCES_CPP_NAMESPACE__DOMError", "XERCES_CPP_NAMESPACE::DOMError *", 0, 0, (void*)"XML::Xerces::DOMError", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMErrorHandler = {"_p_XERCES_CPP_NAMESPACE__DOMErrorHandler", "XERCES_CPP_NAMESPACE::DOMErrorHandler *", 0, 0, (void*)"XML::Xerces::DOMErrorHandler", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMException = {"_p_XERCES_CPP_NAMESPACE__DOMException", "XERCES_CPP_NAMESPACE::DOMException *", 0, 0, (void*)"XML::Xerces::DOMException", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMImplementation = {"_p_XERCES_CPP_NAMESPACE__DOMImplementation", "XERCES_CPP_NAMESPACE::DOMImplementation *", 0, 0, (void*)"XML::Xerces::DOMImplementation", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationLS = {"_p_XERCES_CPP_NAMESPACE__DOMImplementationLS", "XERCES_CPP_NAMESPACE::DOMImplementationLS *", 0, 0, (void*)"XML::Xerces::DOMImplementationLS", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationList = {"_p_XERCES_CPP_NAMESPACE__DOMImplementationList", "XERCES_CPP_NAMESPACE::DOMImplementationList *", 0, 0, (void*)"XML::Xerces::DOMImplementationList", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry = {"_p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry", "XERCES_CPP_NAMESPACE::DOMImplementationRegistry *", 0, 0, (void*)"XML::Xerces::DOMImplementationRegistry", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationSource = {"_p_XERCES_CPP_NAMESPACE__DOMImplementationSource", "XERCES_CPP_NAMESPACE::DOMImplementationSource *", 0, 0, (void*)"XML::Xerces::DOMImplementationSource", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSException = {"_p_XERCES_CPP_NAMESPACE__DOMLSException", "XERCES_CPP_NAMESPACE::DOMLSException *", 0, 0, (void*)"XML::Xerces::DOMLSException", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSInput = {"_p_XERCES_CPP_NAMESPACE__DOMLSInput", "XERCES_CPP_NAMESPACE::DOMLSInput *", 0, 0, (void*)"XML::Xerces::DOMLSInput", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSOutput = {"_p_XERCES_CPP_NAMESPACE__DOMLSOutput", "XERCES_CPP_NAMESPACE::DOMLSOutput *", 0, 0, (void*)"XML::Xerces::DOMLSOutput", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSParser = {"_p_XERCES_CPP_NAMESPACE__DOMLSParser", "XERCES_CPP_NAMESPACE::DOMLSParser *", 0, 0, (void*)"XML::Xerces::DOMLSParser", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSParserFilter = {"_p_XERCES_CPP_NAMESPACE__DOMLSParserFilter", "XERCES_CPP_NAMESPACE::DOMLSParserFilter *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver = {"_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver", "XERCES_CPP_NAMESPACE::DOMLSResourceResolver *", 0, 0, (void*)"XML::Xerces::DOMLSResourceResolver", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializer = {"_p_XERCES_CPP_NAMESPACE__DOMLSSerializer", "XERCES_CPP_NAMESPACE::DOMLSSerializer *", 0, 0, (void*)"XML::Xerces::DOMLSSerializer", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter = {"_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter", "XERCES_CPP_NAMESPACE::DOMLSSerializerFilter *", 0, 0, (void*)"XML::Xerces::DOMLSSerializerFilter", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMLocator = {"_p_XERCES_CPP_NAMESPACE__DOMLocator", "XERCES_CPP_NAMESPACE::DOMLocator *", 0, 0, (void*)"XML::Xerces::DOMLocator", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap = {"_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap", "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *", 0, 0, (void*)"XML::Xerces::DOMNamedNodeMap", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNode = {"_p_XERCES_CPP_NAMESPACE__DOMNode", "XERCES_CPP_NAMESPACE::DOMNode *", 0, 0, (void*)"XML::Xerces::DOMNode", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNodeFilter = {"_p_XERCES_CPP_NAMESPACE__DOMNodeFilter", "XERCES_CPP_NAMESPACE::DOMNodeFilter *", 0, 0, (void*)"XML::Xerces::DOMNodeFilter", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNodeIterator = {"_p_XERCES_CPP_NAMESPACE__DOMNodeIterator", "XERCES_CPP_NAMESPACE::DOMNodeIterator *", 0, 0, (void*)"XML::Xerces::DOMNodeIterator", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNodeList = {"_p_XERCES_CPP_NAMESPACE__DOMNodeList", "XERCES_CPP_NAMESPACE::DOMNodeList *", 0, 0, (void*)"XML::Xerces::DOMNodeList", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNotation = {"_p_XERCES_CPP_NAMESPACE__DOMNotation", "XERCES_CPP_NAMESPACE::DOMNotation *", 0, 0, (void*)"XML::Xerces::DOMNotation", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo = {"_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo", "XERCES_CPP_NAMESPACE::DOMPSVITypeInfo *", 0, 0, (void*)"XML::Xerces::DOMPSVITypeInfo", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction = {"_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction", "XERCES_CPP_NAMESPACE::DOMProcessingInstruction *", 0, 0, (void*)"XML::Xerces::DOMProcessingInstruction", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMRange = {"_p_XERCES_CPP_NAMESPACE__DOMRange", "XERCES_CPP_NAMESPACE::DOMRange *", 0, 0, (void*)"XML::Xerces::DOMRange", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMRangeException = {"_p_XERCES_CPP_NAMESPACE__DOMRangeException", "XERCES_CPP_NAMESPACE::DOMRangeException *", 0, 0, (void*)"XML::Xerces::DOMRangeException", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMStringList = {"_p_XERCES_CPP_NAMESPACE__DOMStringList", "XERCES_CPP_NAMESPACE::DOMStringList *", 0, 0, (void*)"XML::Xerces::DOMStringList", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMText = {"_p_XERCES_CPP_NAMESPACE__DOMText", "XERCES_CPP_NAMESPACE::DOMText *", 0, 0, (void*)"XML::Xerces::DOMText", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMTreeWalker = {"_p_XERCES_CPP_NAMESPACE__DOMTreeWalker", "XERCES_CPP_NAMESPACE::DOMTreeWalker *", 0, 0, (void*)"XML::Xerces::DOMTreeWalker", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMTypeInfo = {"_p_XERCES_CPP_NAMESPACE__DOMTypeInfo", "XERCES_CPP_NAMESPACE::DOMTypeInfo *", 0, 0, (void*)"XML::Xerces::DOMTypeInfo", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler = {"_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler", "XERCES_CPP_NAMESPACE::DOMUserDataHandler *", 0, 0, (void*)"XML::Xerces::DOMUserDataHandler", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator = {"_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator", "XERCES_CPP_NAMESPACE::DOMXPathEvaluator *", 0, 0, (void*)"XML::Xerces::DOMXPathEvaluator", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathException = {"_p_XERCES_CPP_NAMESPACE__DOMXPathException", "XERCES_CPP_NAMESPACE::DOMXPathException *", 0, 0, (void*)"XML::Xerces::DOMXPathException", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathExpression = {"_p_XERCES_CPP_NAMESPACE__DOMXPathExpression", "XERCES_CPP_NAMESPACE::DOMXPathExpression *", 0, 0, (void*)"XML::Xerces::DOMXPathExpression", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver = {"_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver", "XERCES_CPP_NAMESPACE::DOMXPathNSResolver *", 0, 0, (void*)"XML::Xerces::DOMXPathNSResolver", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace = {"_p_XERCES_CPP_NAMESPACE__DOMXPathNamespace", "XERCES_CPP_NAMESPACE::DOMXPathNamespace *", 0, 0, (void*)"XML::Xerces::DOMXPathNamespace", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMXPathResult = {"_p_XERCES_CPP_NAMESPACE__DOMXPathResult", "XERCES_CPP_NAMESPACE::DOMXPathResult *", 0, 0, (void*)"XML::Xerces::DOMXPathResult", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef = {"_p_XERCES_CPP_NAMESPACE__DTDAttDef", "XERCES_CPP_NAMESPACE::DTDAttDef *", 0, 0, (void*)"XML::Xerces::DTDAttDef", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DTDAttDefList = {"_p_XERCES_CPP_NAMESPACE__DTDAttDefList", "XERCES_CPP_NAMESPACE::DTDAttDefList *", 0, 0, (void*)"XML::Xerces::DTDAttDefList", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DTDElementDecl = {"_p_XERCES_CPP_NAMESPACE__DTDElementDecl", "XERCES_CPP_NAMESPACE::DTDElementDecl *", 0, 0, (void*)"XML::Xerces::DTDElementDecl", 0};
@@ -67995,10 +42912,8 @@ static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__GrammarResolver = {"_p_XER
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__HandlerBase = {"_p_XERCES_CPP_NAMESPACE__HandlerBase", "XERCES_CPP_NAMESPACE::HandlerBase *", 0, 0, (void*)"XML::Xerces::HandlerBase", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__InputSource = {"_p_XERCES_CPP_NAMESPACE__InputSource", "XERCES_CPP_NAMESPACE::InputSource *", 0, 0, (void*)"XML::Xerces::InputSource", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__LexicalHandler = {"_p_XERCES_CPP_NAMESPACE__LexicalHandler", "XERCES_CPP_NAMESPACE::LexicalHandler *", 0, 0, (void*)"XML::Xerces::LexicalHandler", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget = {"_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget", "XERCES_CPP_NAMESPACE::LocalFileFormatTarget *", 0, 0, (void*)"XML::Xerces::LocalFileFormatTarget", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource = {"_p_XERCES_CPP_NAMESPACE__LocalFileInputSource", "XERCES_CPP_NAMESPACE::LocalFileInputSource *", 0, 0, (void*)"XML::Xerces::LocalFileInputSource", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__Locator = {"_p_XERCES_CPP_NAMESPACE__Locator", "XERCES_CPP_NAMESPACE::Locator *", 0, 0, (void*)"XML::Xerces::Locator", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget = {"_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget", "XERCES_CPP_NAMESPACE::MemBufFormatTarget *", 0, 0, (void*)"XML::Xerces::MemBufFormatTarget", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource = {"_p_XERCES_CPP_NAMESPACE__MemBufInputSource", "XERCES_CPP_NAMESPACE::MemBufInputSource *", 0, 0, (void*)"XML::Xerces::MemBufInputSource", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__MemoryManager = {"_p_XERCES_CPP_NAMESPACE__MemoryManager", "XERCES_CPP_NAMESPACE::MemoryManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t = {"_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t", "XERCES_CPP_NAMESPACE::NameIdPoolEnumerator<XERCES_CPP_NAMESPACE::DTDElementDecl > *", 0, 0, (void*)"XML::Xerces::DTDElementDeclEnumerator", 0};
@@ -68024,10 +42939,7 @@ static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SchemaElementDecl = {"_p_X
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SchemaGrammar = {"_p_XERCES_CPP_NAMESPACE__SchemaGrammar", "XERCES_CPP_NAMESPACE::SchemaGrammar *", 0, 0, (void*)"XML::Xerces::SchemaGrammar", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator = {"_p_XERCES_CPP_NAMESPACE__SchemaValidator", "XERCES_CPP_NAMESPACE::SchemaValidator *", 0, 0, (void*)"XML::Xerces::SchemaValidator", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource = {"_p_XERCES_CPP_NAMESPACE__StdInInputSource", "XERCES_CPP_NAMESPACE::StdInInputSource *", 0, 0, (void*)"XML::Xerces::StdInInputSource", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget = {"_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget", "XERCES_CPP_NAMESPACE::StdOutFormatTarget *", 0, 0, (void*)"XML::Xerces::StdOutFormatTarget", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__URLInputSource = {"_p_XERCES_CPP_NAMESPACE__URLInputSource", "XERCES_CPP_NAMESPACE::URLInputSource *", 0, 0, (void*)"XML::Xerces::URLInputSource", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput = {"_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput", "XERCES_CPP_NAMESPACE::Wrapper4DOMLSInput *", 0, 0, (void*)"XML::Xerces::Wrapper4DOMLSInput", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource = {"_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource", "XERCES_CPP_NAMESPACE::Wrapper4InputSource *", 0, 0, (void*)"XML::Xerces::Wrapper4InputSource", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLAttDef = {"_p_XERCES_CPP_NAMESPACE__XMLAttDef", "XERCES_CPP_NAMESPACE::XMLAttDef *", 0, 0, (void*)"XML::Xerces::XMLAttDef", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLAttDefList = {"_p_XERCES_CPP_NAMESPACE__XMLAttDefList", "XERCES_CPP_NAMESPACE::XMLAttDefList *", 0, 0, (void*)"XML::Xerces::XMLAttDefList", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLContentModel = {"_p_XERCES_CPP_NAMESPACE__XMLContentModel", "XERCES_CPP_NAMESPACE::XMLContentModel *", 0, 0, (void*)0, 0};
@@ -68042,8 +42954,6 @@ static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_N
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t = {"_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t", "XERCES_CPP_NAMESPACE::XMLEnumerator<XERCES_CPP_NAMESPACE::SchemaElementDecl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLException = {"_p_XERCES_CPP_NAMESPACE__XMLException", "XERCES_CPP_NAMESPACE::XMLException *", 0, 0, (void*)"XML::Xerces::XMLException", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLExcepts = {"_p_XERCES_CPP_NAMESPACE__XMLExcepts", "XERCES_CPP_NAMESPACE::XMLExcepts *", 0, 0, (void*)"XML::Xerces::XMLExcepts", 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLFormatTarget = {"_p_XERCES_CPP_NAMESPACE__XMLFormatTarget", "XERCES_CPP_NAMESPACE::XMLFormatTarget *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLFormatter = {"_p_XERCES_CPP_NAMESPACE__XMLFormatter", "XERCES_CPP_NAMESPACE::XMLFormatter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription = {"_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription", "XERCES_CPP_NAMESPACE::XMLGrammarDescription *", 0, 0, (void*)"XML::Xerces::XMLGrammarDescription", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarPool = {"_p_XERCES_CPP_NAMESPACE__XMLGrammarPool", "XERCES_CPP_NAMESPACE::XMLGrammarPool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl = {"_p_XERCES_CPP_NAMESPACE__XMLNotationDecl", "XERCES_CPP_NAMESPACE::XMLNotationDecl *", 0, 0, (void*)"XML::Xerces::XMLNotationDecl", 0};
@@ -68057,7 +42967,6 @@ static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLUri = {"_p_XERCES_CPP_N
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLValidator = {"_p_XERCES_CPP_NAMESPACE__XMLValidator", "XERCES_CPP_NAMESPACE::XMLValidator *", 0, 0, (void*)"XML::Xerces::XMLValidator", 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMemory = {"_p_XERCES_CPP_NAMESPACE__XMemory", "XERCES_CPP_NAMESPACE::XMemory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XSAnnotation = {"_p_XERCES_CPP_NAMESPACE__XSAnnotation", "XERCES_CPP_NAMESPACE::XSAnnotation *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser = {"_p_XERCES_CPP_NAMESPACE__XercesDOMParser", "XERCES_CPP_NAMESPACE::XercesDOMParser *", 0, 0, (void*)"XML::Xerces::XercesDOMParser", 0};
static swig_type_info _swigt__p_XMLAtomicOpMgr = {"_p_XMLAtomicOpMgr", "XMLAtomicOpMgr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLBuffer = {"_p_XMLBuffer", "XMLBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_XMLErrorReporter = {"_p_XMLErrorReporter", "XMLErrorReporter *", 0, 0, (void*)0, 0};
@@ -68090,7 +42999,6 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_PerlDocumentCallbackHandler,
&_swigt__p_PerlEntityResolverHandler,
&_swigt__p_PerlErrorCallbackHandler,
- &_swigt__p_PerlNodeFilterCallbackHandler,
&_swigt__p_RefArrayVectorOfTuint16_t_t,
&_swigt__p_RefHash2KeysTableOfTValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t_t,
&_swigt__p_RefHashTableOfTXERCES_CPP_NAMESPACE__ComplexTypeInfo_t,
@@ -68102,64 +43010,12 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_ValidationContext,
&_swigt__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t,
&_swigt__p_ValueVectorOfTunsigned_int_t,
- &_swigt__p_XERCES_CPP_NAMESPACE__AbstractDOMParser,
&_swigt__p_XERCES_CPP_NAMESPACE__AttributeList,
&_swigt__p_XERCES_CPP_NAMESPACE__Attributes,
&_swigt__p_XERCES_CPP_NAMESPACE__BinInputStream,
&_swigt__p_XERCES_CPP_NAMESPACE__ComplexTypeInfo,
&_swigt__p_XERCES_CPP_NAMESPACE__ContentHandler,
&_swigt__p_XERCES_CPP_NAMESPACE__ContentSpecNode,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMAttr,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMComment,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMConfiguration,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentRange,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMElement,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMEntity,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMError,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMErrorHandler,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMException,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementation,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationLS,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationList,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationSource,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSException,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSInput,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSOutput,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSParser,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSParserFilter,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializer,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMLocator,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMNode,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeFilter,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeIterator,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeList,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMNotation,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMRange,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMRangeException,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMStringList,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMText,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMTreeWalker,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMTypeInfo,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathException,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathExpression,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace,
- &_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathResult,
&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef,
&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDefList,
&_swigt__p_XERCES_CPP_NAMESPACE__DTDElementDecl,
@@ -68178,10 +43034,8 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_XERCES_CPP_NAMESPACE__HandlerBase,
&_swigt__p_XERCES_CPP_NAMESPACE__InputSource,
&_swigt__p_XERCES_CPP_NAMESPACE__LexicalHandler,
- &_swigt__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget,
&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource,
&_swigt__p_XERCES_CPP_NAMESPACE__Locator,
- &_swigt__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget,
&_swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource,
&_swigt__p_XERCES_CPP_NAMESPACE__MemoryManager,
&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t,
@@ -68207,10 +43061,7 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_XERCES_CPP_NAMESPACE__SchemaGrammar,
&_swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator,
&_swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource,
- &_swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget,
&_swigt__p_XERCES_CPP_NAMESPACE__URLInputSource,
- &_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput,
- &_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource,
&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDef,
&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDefList,
&_swigt__p_XERCES_CPP_NAMESPACE__XMLContentModel,
@@ -68225,8 +43076,6 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t,
&_swigt__p_XERCES_CPP_NAMESPACE__XMLException,
&_swigt__p_XERCES_CPP_NAMESPACE__XMLExcepts,
- &_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatTarget,
- &_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatter,
&_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription,
&_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarPool,
&_swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl,
@@ -68240,7 +43089,6 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_XERCES_CPP_NAMESPACE__XMLValidator,
&_swigt__p_XERCES_CPP_NAMESPACE__XMemory,
&_swigt__p_XERCES_CPP_NAMESPACE__XSAnnotation,
- &_swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser,
&_swigt__p_XMLAtomicOpMgr,
&_swigt__p_XMLBuffer,
&_swigt__p_XMLErrorReporter,
@@ -68268,12 +43116,11 @@ static swig_cast_info _swigc__p_PSVIDefs__PSVIScope[] = { {&_swigt__p_PSVIDefs_
static swig_cast_info _swigc__p_PSVIElement[] = { {&_swigt__p_PSVIElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PanicHandler[] = { {&_swigt__p_PanicHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PanicHandler__PanicReasons[] = { {&_swigt__p_PanicHandler__PanicReasons, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_PerlCallbackHandler[] = { {&_swigt__p_PerlCallbackHandler, 0, 0, 0}, {&_swigt__p_PerlErrorCallbackHandler, _p_PerlErrorCallbackHandlerTo_p_PerlCallbackHandler, 0, 0}, {&_swigt__p_PerlEntityResolverHandler, _p_PerlEntityResolverHandlerTo_p_PerlCallbackHandler, 0, 0}, {&_swigt__p_PerlNodeFilterCallbackHandler, _p_PerlNodeFilterCallbackHandlerTo_p_PerlCallbackHandler, 0, 0}, {&_swigt__p_PerlDocumentCallbackHandler, _p_PerlDocumentCallbackHandlerTo_p_PerlCallbackHandler, 0, 0}, {&_swigt__p_PerlContentCallbackHandler, _p_PerlContentCallbackHandlerTo_p_PerlCallbackHandler, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_PerlCallbackHandler[] = { {&_swigt__p_PerlCallbackHandler, 0, 0, 0}, {&_swigt__p_PerlErrorCallbackHandler, _p_PerlErrorCallbackHandlerTo_p_PerlCallbackHandler, 0, 0}, {&_swigt__p_PerlEntityResolverHandler, _p_PerlEntityResolverHandlerTo_p_PerlCallbackHandler, 0, 0}, {&_swigt__p_PerlDocumentCallbackHandler, _p_PerlDocumentCallbackHandlerTo_p_PerlCallbackHandler, 0, 0}, {&_swigt__p_PerlContentCallbackHandler, _p_PerlContentCallbackHandlerTo_p_PerlCallbackHandler, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PerlContentCallbackHandler[] = { {&_swigt__p_PerlContentCallbackHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PerlDocumentCallbackHandler[] = { {&_swigt__p_PerlDocumentCallbackHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PerlEntityResolverHandler[] = { {&_swigt__p_PerlEntityResolverHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PerlErrorCallbackHandler[] = { {&_swigt__p_PerlErrorCallbackHandler, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_PerlNodeFilterCallbackHandler[] = { {&_swigt__p_PerlNodeFilterCallbackHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RefArrayVectorOfTuint16_t_t[] = { {&_swigt__p_RefArrayVectorOfTuint16_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RefHash2KeysTableOfTValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t_t[] = { {&_swigt__p_RefHash2KeysTableOfTValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RefHashTableOfTXERCES_CPP_NAMESPACE__ComplexTypeInfo_t[] = { {&_swigt__p_RefHashTableOfTXERCES_CPP_NAMESPACE__ComplexTypeInfo_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -68285,64 +43132,12 @@ static swig_cast_info _swigc__p_SecurityManager[] = { {&_swigt__p_SecurityManag
static swig_cast_info _swigc__p_ValidationContext[] = { {&_swigt__p_ValidationContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t[] = { {&_swigt__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ValueVectorOfTunsigned_int_t[] = { {&_swigt__p_ValueVectorOfTunsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__AbstractDOMParser[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser, _p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__AttributeList[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__AttributeList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__Attributes[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__Attributes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__BinInputStream[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__BinInputStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__ComplexTypeInfo[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__ComplexTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__ContentHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__ContentHandler, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DefaultHandler, _p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__ContentHandler, 0, 0}, {&_swigt__p_PerlContentCallbackHandler, _p_PerlContentCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__ContentHandler, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__ContentSpecNode[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__ContentSpecNode, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMAttr[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMAttr, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMCDATASection[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMCharacterData[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMText, _p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMComment, _p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, _p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMComment[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMComment, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMConfiguration[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMConfiguration, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocument[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentRange[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentRange, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument, _p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMDocumentRange, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument, _p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentType[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMElement[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMElement, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMEntity[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntity, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMEntityReference[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMError[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMError, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMErrorHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMErrorHandler, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMException[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMException, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMRangeException, _p_XERCES_CPP_NAMESPACE__DOMRangeExceptionTo_p_XERCES_CPP_NAMESPACE__DOMException, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSException, _p_XERCES_CPP_NAMESPACE__DOMLSExceptionTo_p_XERCES_CPP_NAMESPACE__DOMException, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementation[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementation, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationLS[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementation, _p_XERCES_CPP_NAMESPACE__DOMImplementationTo_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationLS, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationList[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationList, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationSource[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMImplementationSource, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSException[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSException, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSInput[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, _p_XERCES_CPP_NAMESPACE__Wrapper4InputSourceTo_p_XERCES_CPP_NAMESPACE__DOMLSInput, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSInput, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSOutput[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSOutput, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSParser[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSParser, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSParserFilter[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSParserFilter, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSSerializer[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializer, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMLocator[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLocator, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNode[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMAttr, _p_XERCES_CPP_NAMESPACE__DOMAttrTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNotation, _p_XERCES_CPP_NAMESPACE__DOMNotationTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMText, _p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, _p_XERCES_CPP_NAMESPACE__DOMDocumentFragmentTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace, _p_XERCES_CPP_NAMESPACE__DOMXPathNamespaceTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, _p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference, _p_XERCES_CPP_NAMESPACE__DOMEntityReferenceTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntity, _p_XERCES_CPP_NAMESPACE__DOMEntityTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData, _p_XERCES_CPP_NAMESPACE__DOMCharacterDataTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType, _p_XERCES_CPP_NAMESPACE__DOMDocumentTypeTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMComment, _p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument, _p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMElement, _p_XERCES_CPP_NAMESPACE__DOMElementTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, _p_XERCES_CPP_NAMESPACE__DOMProcessingInstructionTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeFilter[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, _p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilterTo_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0, 0, 0}, {&_swigt__p_PerlNodeFilterCallbackHandler, _p_PerlNodeFilterCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeIterator[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeIterator, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeList[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeList, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNotation[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNotation, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMRange[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMRange, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMRangeException[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMRangeException, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMStringList[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMStringList, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMText[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMText, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, _p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMText, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMTreeWalker[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMTreeWalker, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMTypeInfo[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument, _p_XERCES_CPP_NAMESPACE__DOMDocumentTo_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathException[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathException, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathExpression[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathExpression, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathResult[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DOMXPathResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DTDAttDef[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DTDAttDefList[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDefList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DTDElementDecl[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DTDElementDecl, 0, 0, 0},{0, 0, 0, 0}};
@@ -68359,12 +43154,10 @@ static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__ErrorHandler[] = { {&_swi
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__Grammar[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__Grammar, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDGrammar, _p_XERCES_CPP_NAMESPACE__DTDGrammarTo_p_XERCES_CPP_NAMESPACE__Grammar, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaGrammar, _p_XERCES_CPP_NAMESPACE__SchemaGrammarTo_p_XERCES_CPP_NAMESPACE__Grammar, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__GrammarResolver[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__GrammarResolver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__HandlerBase[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__HandlerBase, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__InputSource[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__InputSource, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource, _p_XERCES_CPP_NAMESPACE__LocalFileInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource, _p_XERCES_CPP_NAMESPACE__StdInInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__URLInputSource, _p_XERCES_CPP_NAMESPACE__URLInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource, _p_XERCES_CPP_NAMESPACE__MemBufInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, _p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInputTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__InputSource[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__InputSource, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource, _p_XERCES_CPP_NAMESPACE__LocalFileInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource, _p_XERCES_CPP_NAMESPACE__StdInInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__URLInputSource, _p_XERCES_CPP_NAMESPACE__URLInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource, _p_XERCES_CPP_NAMESPACE__MemBufInputSourceTo_p_XERCES_CPP_NAMESPACE__InputSource, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__LexicalHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__LexicalHandler, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DefaultHandler, _p_XERCES_CPP_NAMESPACE__DefaultHandlerTo_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__LocalFileInputSource[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__Locator[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__Locator, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__MemBufInputSource[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__MemoryManager[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__MemoryManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -68373,7 +43166,7 @@ static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCE
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__NamespaceScope[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__NamespaceScope, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__PSVIHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__AbstractDOMParser, _p_XERCES_CPP_NAMESPACE__AbstractDOMParserTo_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser, _p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__PSVIHandler, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__PSVIHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__PSVIHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__PSVIHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__Parser[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__SAXParser, _p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XERCES_CPP_NAMESPACE__Parser, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__Parser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__QName[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__QName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -68390,10 +43183,7 @@ static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SchemaElementDecl[] = { {
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SchemaGrammar[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaGrammar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SchemaValidator[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__StdInInputSource[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__URLInputSource[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__URLInputSource, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLAttDef[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDef, _p_XERCES_CPP_NAMESPACE__SchemaAttDefTo_p_XERCES_CPP_NAMESPACE__XMLAttDef, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDef, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef, _p_XERCES_CPP_NAMESPACE__DTDAttDefTo_p_XERCES_CPP_NAMESPACE__XMLAttDef, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLAttDefList[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDefList, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDefList, _p_XERCES_CPP_NAMESPACE__DTDAttDefListTo_p_XERCES_CPP_NAMESPACE__XMLAttDefList, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDefList, _p_XERCES_CPP_NAMESPACE__SchemaAttDefListTo_p_XERCES_CPP_NAMESPACE__XMLAttDefList, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLContentModel[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLContentModel, 0, 0, 0},{0, 0, 0, 0}};
@@ -68408,8 +43198,6 @@ static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_N
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, _p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLException[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLExcepts[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLExcepts, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLFormatTarget[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, _p_XERCES_CPP_NAMESPACE__StdOutFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, _p_XERCES_CPP_NAMESPACE__LocalFileFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, _p_XERCES_CPP_NAMESPACE__MemBufFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLFormatter[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLDTDDescription, _p_XERCES_CPP_NAMESPACE__XMLDTDDescriptionTo_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLSchemaDescription, _p_XERCES_CPP_NAMESPACE__XMLSchemaDescriptionTo_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLGrammarPool[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarPool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLNotationDecl[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl, 0, 0, 0},{0, 0, 0, 0}};
@@ -68421,12 +43209,11 @@ static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLURL[] = { {&_swigt__p_
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLUni[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLUni, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLUri[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLUri, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLValidator[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLValidator, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDValidator, _p_XERCES_CPP_NAMESPACE__DTDValidatorTo_p_XERCES_CPP_NAMESPACE__XMLValidator, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator, _p_XERCES_CPP_NAMESPACE__SchemaValidatorTo_p_XERCES_CPP_NAMESPACE__XMLValidator, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMemory[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLUri, _p_XERCES_CPP_NAMESPACE__XMLUriTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLSchemaDescription, _p_XERCES_CPP_NAMESPACE__XMLSchemaDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription, _p_XERCES_CPP_NAMESPACE__XMLGrammarDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLDTDDescription, _p_XERCES_CPP_NAMESPACE__XMLDTDDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaElementDecl, _p_XERCES_CPP_NAMESPACE__SchemaElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDElementDecl, _p_XERCES_CPP_NAMESPACE__DTDElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLElementDecl, _p_XERCES_CPP_NAMESPACE__XMLElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator, _p_XERCES_CPP_NAMESPACE__SchemaValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDValidator, _p_XERCES_CPP_NAMESPACE__DTDValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLValidator, _p_XERCES_CPP_NAMESPACE__XMLValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLPScanToken, _p_XERCES_CPP_NAMESPACE__XMLPScanTokenTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, _p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDef, _p_XERCES_CPP_NAMESPACE__XMLAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef, _p_XERCES_CPP_NAMESPACE__DTDAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXParser, _p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl, _p_XERCES_CPP_NAMESPACE__XMLNotationDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatTarget, _p_XERCES_CPP_NAMESPACE__XMLFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, _p_XERCES_CPP_NAMESPACE__StdOutFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, _p_XERCES_CPP_NAMESPACE__LocalFileFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, _p_XERCES_CPP_NAMESPACE__MemBufFormatTargetTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource, _p_XERCES_CPP_NAMESPACE__LocalFileInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__InputSource, _p_XERCES_CPP_NAMESPACE__InputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource, _p_XERCES_CPP_NAMESPACE__StdInInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__URLInputSource, _p_XERCES_CPP_NAMESPACE__URLInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource, _p_XERCES_CPP_NAMESPACE__MemBufInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDef, _p_XERCES_CPP_NAMESPACE__SchemaAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__AbstractDOMParser, _p_XERCES_CPP_NAMESPACE__AbstractDOMParserTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser, _p_XERCES_CPP_NAMESPACE__XercesDOMParserTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLURL, _p_XERCES_CPP_NAMESPACE__XMLURLTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLException, _p_XERCES_CPP_NAMESPACE__XMLExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLContentModel, _p_XERCES_CPP_NAMESPACE__XMLContentModelTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDGrammar, _p_XERCES_CPP_NAMESPACE__DTDGrammarTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaGrammar, _p_XERCES_CPP_NAMESPACE__SchemaGrammarTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__Grammar, _p_XERCES_CPP_NAMESPACE__GrammarTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXException, _p_XERCES_CPP_NAMESPACE__SAXExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, _p_XERCES_CPP_NAMESPACE__SAXNotSupportedExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException, _p_XERCES_CPP_NAMESPACE__SAXNotRecognizedExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXParseException, _p_XERCES_CPP_NAMESPACE__SAXParseExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, _p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMemory, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__QName, _p_XERCES_CPP_NAMESPACE__QNameTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, _p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInputTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDefList, _p_XERCES_CPP_NAMESPACE__SchemaAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDefList, _p_XERCES_CPP_NAMESPACE__DTDAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDefList, _p_XERCES_CPP_NAMESPACE__XMLAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatter, _p_XERCES_CPP_NAMESPACE__XMLFormatterTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDEntityDecl, _p_XERCES_CPP_NAMESPACE__DTDEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLEntityDecl, _p_XERCES_CPP_NAMESPACE__XMLEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMemory[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLUri, _p_XERCES_CPP_NAMESPACE__XMLUriTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLSchemaDescription, _p_XERCES_CPP_NAMESPACE__XMLSchemaDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription, _p_XERCES_CPP_NAMESPACE__XMLGrammarDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLDTDDescription, _p_XERCES_CPP_NAMESPACE__XMLDTDDescriptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaElementDecl, _p_XERCES_CPP_NAMESPACE__SchemaElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDElementDecl, _p_XERCES_CPP_NAMESPACE__DTDElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLElementDecl, _p_XERCES_CPP_NAMESPACE__XMLElementDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator, _p_XERCES_CPP_NAMESPACE__SchemaValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDValidator, _p_XERCES_CPP_NAMESPACE__DTDValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLValidator, _p_XERCES_CPP_NAMESPACE__XMLValidatorTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLPScanToken, _p_XERCES_CPP_NAMESPACE__XMLPScanTokenTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, _p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDef, _p_XERCES_CPP_NAMESPACE__XMLAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef, _p_XERCES_CPP_NAMESPACE__DTDAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXParser, _p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl, _p_XERCES_CPP_NAMESPACE__XMLNotationDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__LocalFileInputSource, _p_XERCES_CPP_NAMESPACE__LocalFileInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__InputSource, _p_XERCES_CPP_NAMESPACE__InputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource, _p_XERCES_CPP_NAMESPACE__StdInInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__URLInputSource, _p_XERCES_CPP_NAMESPACE__URLInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__MemBufInputSource, _p_XERCES_CPP_NAMESPACE__MemBufInputSourceTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDef, _p_XERCES_CPP_NAMESPACE__SchemaAttDefTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLURL, _p_XERCES_CPP_NAMESPACE__XMLURLTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLException, _p_XERCES_CPP_NAMESPACE__XMLExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXException, _p_XERCES_CPP_NAMESPACE__SAXExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, _p_XERCES_CPP_NAMESPACE__SAXNotSupportedExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException, _p_XERCES_CPP_NAMESPACE__SAXNotRecognizedExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SAXParseException, _p_XERCES_CPP_NAMESPACE__SAXParseExceptionTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLContentModel, _p_XERCES_CPP_NAMESPACE__XMLContentModelTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDGrammar, _p_XERCES_CPP_NAMESPACE__DTDGrammarTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__Grammar, _p_XERCES_CPP_NAMESPACE__GrammarTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaGrammar, _p_XERCES_CPP_NAMESPACE__SchemaGrammarTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t, _p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t, _p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMemory, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__QName, _p_XERCES_CPP_NAMESPACE__QNameTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__SchemaAttDefList, _p_XERCES_CPP_NAMESPACE__SchemaAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDefList, _p_XERCES_CPP_NAMESPACE__DTDAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDefList, _p_XERCES_CPP_NAMESPACE__XMLAttDefListTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDEntityDecl, _p_XERCES_CPP_NAMESPACE__DTDEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLEntityDecl, _p_XERCES_CPP_NAMESPACE__XMLEntityDeclTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XSAnnotation[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XSAnnotation, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XercesDOMParser[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLAtomicOpMgr[] = { {&_swigt__p_XMLAtomicOpMgr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLBuffer[] = { {&_swigt__p_XMLBuffer, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_XMLErrorReporter[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__SAXParser, _p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XMLErrorReporter, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__AbstractDOMParser, _p_XERCES_CPP_NAMESPACE__AbstractDOMParserTo_p_XMLErrorReporter, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XercesDOMParser, 0, 0, 0}, {&_swigt__p_XMLErrorReporter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XMLErrorReporter[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__SAXParser, _p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XMLErrorReporter, 0, 0}, {&_swigt__p_XMLErrorReporter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLErrorReporter__ErrTypes[] = { {&_swigt__p_XMLErrorReporter__ErrTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLFileMgr[] = { {&_swigt__p_XMLFileMgr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_XMLMutexMgr[] = { {&_swigt__p_XMLMutexMgr, 0, 0, 0},{0, 0, 0, 0}};
@@ -68456,7 +43243,6 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_PerlDocumentCallbackHandler,
_swigc__p_PerlEntityResolverHandler,
_swigc__p_PerlErrorCallbackHandler,
- _swigc__p_PerlNodeFilterCallbackHandler,
_swigc__p_RefArrayVectorOfTuint16_t_t,
_swigc__p_RefHash2KeysTableOfTValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t_t,
_swigc__p_RefHashTableOfTXERCES_CPP_NAMESPACE__ComplexTypeInfo_t,
@@ -68468,64 +43254,12 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_ValidationContext,
_swigc__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t,
_swigc__p_ValueVectorOfTunsigned_int_t,
- _swigc__p_XERCES_CPP_NAMESPACE__AbstractDOMParser,
_swigc__p_XERCES_CPP_NAMESPACE__AttributeList,
_swigc__p_XERCES_CPP_NAMESPACE__Attributes,
_swigc__p_XERCES_CPP_NAMESPACE__BinInputStream,
_swigc__p_XERCES_CPP_NAMESPACE__ComplexTypeInfo,
_swigc__p_XERCES_CPP_NAMESPACE__ContentHandler,
_swigc__p_XERCES_CPP_NAMESPACE__ContentSpecNode,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMAttr,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMCDATASection,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMCharacterData,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMComment,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMConfiguration,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMDocument,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentRange,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentType,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMElement,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMEntity,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMEntityReference,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMError,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMErrorHandler,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMException,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementation,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationLS,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationList,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMImplementationSource,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMLSException,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMLSInput,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMLSOutput,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMLSParser,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMLSParserFilter,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMLSSerializer,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMLocator,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMNode,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeFilter,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeIterator,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeList,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMNotation,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMRange,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMRangeException,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMStringList,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMText,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMTreeWalker,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMTypeInfo,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathException,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathExpression,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathNamespace,
- _swigc__p_XERCES_CPP_NAMESPACE__DOMXPathResult,
_swigc__p_XERCES_CPP_NAMESPACE__DTDAttDef,
_swigc__p_XERCES_CPP_NAMESPACE__DTDAttDefList,
_swigc__p_XERCES_CPP_NAMESPACE__DTDElementDecl,
@@ -68544,10 +43278,8 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_XERCES_CPP_NAMESPACE__HandlerBase,
_swigc__p_XERCES_CPP_NAMESPACE__InputSource,
_swigc__p_XERCES_CPP_NAMESPACE__LexicalHandler,
- _swigc__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget,
_swigc__p_XERCES_CPP_NAMESPACE__LocalFileInputSource,
_swigc__p_XERCES_CPP_NAMESPACE__Locator,
- _swigc__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget,
_swigc__p_XERCES_CPP_NAMESPACE__MemBufInputSource,
_swigc__p_XERCES_CPP_NAMESPACE__MemoryManager,
_swigc__p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t,
@@ -68573,10 +43305,7 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_XERCES_CPP_NAMESPACE__SchemaGrammar,
_swigc__p_XERCES_CPP_NAMESPACE__SchemaValidator,
_swigc__p_XERCES_CPP_NAMESPACE__StdInInputSource,
- _swigc__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget,
_swigc__p_XERCES_CPP_NAMESPACE__URLInputSource,
- _swigc__p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput,
- _swigc__p_XERCES_CPP_NAMESPACE__Wrapper4InputSource,
_swigc__p_XERCES_CPP_NAMESPACE__XMLAttDef,
_swigc__p_XERCES_CPP_NAMESPACE__XMLAttDefList,
_swigc__p_XERCES_CPP_NAMESPACE__XMLContentModel,
@@ -68591,8 +43320,6 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_XERCES_CPP_NAMESPACE__XMLEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t,
_swigc__p_XERCES_CPP_NAMESPACE__XMLException,
_swigc__p_XERCES_CPP_NAMESPACE__XMLExcepts,
- _swigc__p_XERCES_CPP_NAMESPACE__XMLFormatTarget,
- _swigc__p_XERCES_CPP_NAMESPACE__XMLFormatter,
_swigc__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription,
_swigc__p_XERCES_CPP_NAMESPACE__XMLGrammarPool,
_swigc__p_XERCES_CPP_NAMESPACE__XMLNotationDecl,
@@ -68606,7 +43333,6 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_XERCES_CPP_NAMESPACE__XMLValidator,
_swigc__p_XERCES_CPP_NAMESPACE__XMemory,
_swigc__p_XERCES_CPP_NAMESPACE__XSAnnotation,
- _swigc__p_XERCES_CPP_NAMESPACE__XercesDOMParser,
_swigc__p_XMLAtomicOpMgr,
_swigc__p_XMLBuffer,
_swigc__p_XMLErrorReporter,
@@ -69327,418 +44053,6 @@ static swig_command_info swig_commands[] = {
{"XML::Xercesc::MemBufInputSource_makeStream", _wrap_MemBufInputSource_makeStream},
{"XML::Xercesc::MemBufInputSource_setCopyBufToStream", _wrap_MemBufInputSource_setCopyBufToStream},
{"XML::Xercesc::MemBufInputSource_resetMemBufInputSource", _wrap_MemBufInputSource_resetMemBufInputSource},
-{"XML::Xercesc::new_DOMException", _wrap_new_DOMException},
-{"XML::Xercesc::delete_DOMException", _wrap_delete_DOMException},
-{"XML::Xercesc::DOMException_getMessage", _wrap_DOMException_getMessage},
-{"XML::Xercesc::DOMException_code_set", _wrap_DOMException_code_set},
-{"XML::Xercesc::DOMException_code_get", _wrap_DOMException_code_get},
-{"XML::Xercesc::DOMException_msg_set", _wrap_DOMException_msg_set},
-{"XML::Xercesc::DOMException_msg_get", _wrap_DOMException_msg_get},
-{"XML::Xercesc::delete_DOMNode", _wrap_delete_DOMNode},
-{"XML::Xercesc::DOMNode_getNodeName", _wrap_DOMNode_getNodeName},
-{"XML::Xercesc::DOMNode_getNodeValue", _wrap_DOMNode_getNodeValue},
-{"XML::Xercesc::DOMNode_getNodeType", _wrap_DOMNode_getNodeType},
-{"XML::Xercesc::DOMNode_getParentNode", _wrap_DOMNode_getParentNode},
-{"XML::Xercesc::DOMNode_getChildNodes", _wrap_DOMNode_getChildNodes},
-{"XML::Xercesc::DOMNode_getFirstChild", _wrap_DOMNode_getFirstChild},
-{"XML::Xercesc::DOMNode_getLastChild", _wrap_DOMNode_getLastChild},
-{"XML::Xercesc::DOMNode_getPreviousSibling", _wrap_DOMNode_getPreviousSibling},
-{"XML::Xercesc::DOMNode_getNextSibling", _wrap_DOMNode_getNextSibling},
-{"XML::Xercesc::DOMNode_getAttributes", _wrap_DOMNode_getAttributes},
-{"XML::Xercesc::DOMNode_getOwnerDocument", _wrap_DOMNode_getOwnerDocument},
-{"XML::Xercesc::DOMNode_cloneNode", _wrap_DOMNode_cloneNode},
-{"XML::Xercesc::DOMNode_insertBefore", _wrap_DOMNode_insertBefore},
-{"XML::Xercesc::DOMNode_replaceChild", _wrap_DOMNode_replaceChild},
-{"XML::Xercesc::DOMNode_removeChild", _wrap_DOMNode_removeChild},
-{"XML::Xercesc::DOMNode_appendChild", _wrap_DOMNode_appendChild},
-{"XML::Xercesc::DOMNode_hasChildNodes", _wrap_DOMNode_hasChildNodes},
-{"XML::Xercesc::DOMNode_setNodeValue", _wrap_DOMNode_setNodeValue},
-{"XML::Xercesc::DOMNode_normalize", _wrap_DOMNode_normalize},
-{"XML::Xercesc::DOMNode_isSupported", _wrap_DOMNode_isSupported},
-{"XML::Xercesc::DOMNode_getNamespaceURI", _wrap_DOMNode_getNamespaceURI},
-{"XML::Xercesc::DOMNode_getLocalName", _wrap_DOMNode_getLocalName},
-{"XML::Xercesc::DOMNode_setPrefix", _wrap_DOMNode_setPrefix},
-{"XML::Xercesc::DOMNode_hasAttributes", _wrap_DOMNode_hasAttributes},
-{"XML::Xercesc::DOMNode_isSameNode", _wrap_DOMNode_isSameNode},
-{"XML::Xercesc::DOMNode_isEqualNode", _wrap_DOMNode_isEqualNode},
-{"XML::Xercesc::DOMNode_setUserData", _wrap_DOMNode_setUserData},
-{"XML::Xercesc::DOMNode_getUserData", _wrap_DOMNode_getUserData},
-{"XML::Xercesc::DOMNode_getBaseURI", _wrap_DOMNode_getBaseURI},
-{"XML::Xercesc::DOMNode_compareDocumentPosition", _wrap_DOMNode_compareDocumentPosition},
-{"XML::Xercesc::DOMNode_getTextContent", _wrap_DOMNode_getTextContent},
-{"XML::Xercesc::DOMNode_setTextContent", _wrap_DOMNode_setTextContent},
-{"XML::Xercesc::DOMNode_lookupPrefix", _wrap_DOMNode_lookupPrefix},
-{"XML::Xercesc::DOMNode_isDefaultNamespace", _wrap_DOMNode_isDefaultNamespace},
-{"XML::Xercesc::DOMNode_lookupNamespaceURI", _wrap_DOMNode_lookupNamespaceURI},
-{"XML::Xercesc::DOMNode_getFeature", _wrap_DOMNode_getFeature},
-{"XML::Xercesc::DOMNode_release", _wrap_DOMNode_release},
-{"XML::Xercesc::DOMNode___eq__", _wrap_DOMNode___eq__},
-{"XML::Xercesc::DOMNode___ne__", _wrap_DOMNode___ne__},
-{"XML::Xercesc::delete_DOMAttr", _wrap_delete_DOMAttr},
-{"XML::Xercesc::DOMAttr_getName", _wrap_DOMAttr_getName},
-{"XML::Xercesc::DOMAttr_getSpecified", _wrap_DOMAttr_getSpecified},
-{"XML::Xercesc::DOMAttr_getValue", _wrap_DOMAttr_getValue},
-{"XML::Xercesc::DOMAttr_setValue", _wrap_DOMAttr_setValue},
-{"XML::Xercesc::DOMAttr_getOwnerElement", _wrap_DOMAttr_getOwnerElement},
-{"XML::Xercesc::DOMAttr_isId", _wrap_DOMAttr_isId},
-{"XML::Xercesc::DOMAttr_getSchemaTypeInfo", _wrap_DOMAttr_getSchemaTypeInfo},
-{"XML::Xercesc::delete_DOMElement", _wrap_delete_DOMElement},
-{"XML::Xercesc::DOMElement_getTagName", _wrap_DOMElement_getTagName},
-{"XML::Xercesc::DOMElement_getAttribute", _wrap_DOMElement_getAttribute},
-{"XML::Xercesc::DOMElement_getAttributeNode", _wrap_DOMElement_getAttributeNode},
-{"XML::Xercesc::DOMElement_getElementsByTagName", _wrap_DOMElement_getElementsByTagName},
-{"XML::Xercesc::DOMElement_setAttribute", _wrap_DOMElement_setAttribute},
-{"XML::Xercesc::DOMElement_setAttributeNode", _wrap_DOMElement_setAttributeNode},
-{"XML::Xercesc::DOMElement_removeAttributeNode", _wrap_DOMElement_removeAttributeNode},
-{"XML::Xercesc::DOMElement_removeAttribute", _wrap_DOMElement_removeAttribute},
-{"XML::Xercesc::DOMElement_getAttributeNS", _wrap_DOMElement_getAttributeNS},
-{"XML::Xercesc::DOMElement_setAttributeNS", _wrap_DOMElement_setAttributeNS},
-{"XML::Xercesc::DOMElement_removeAttributeNS", _wrap_DOMElement_removeAttributeNS},
-{"XML::Xercesc::DOMElement_getAttributeNodeNS", _wrap_DOMElement_getAttributeNodeNS},
-{"XML::Xercesc::DOMElement_setAttributeNodeNS", _wrap_DOMElement_setAttributeNodeNS},
-{"XML::Xercesc::DOMElement_getElementsByTagNameNS", _wrap_DOMElement_getElementsByTagNameNS},
-{"XML::Xercesc::DOMElement_hasAttribute", _wrap_DOMElement_hasAttribute},
-{"XML::Xercesc::DOMElement_hasAttributeNS", _wrap_DOMElement_hasAttributeNS},
-{"XML::Xercesc::DOMElement_setIdAttribute", _wrap_DOMElement_setIdAttribute},
-{"XML::Xercesc::DOMElement_setIdAttributeNS", _wrap_DOMElement_setIdAttributeNS},
-{"XML::Xercesc::DOMElement_setIdAttributeNode", _wrap_DOMElement_setIdAttributeNode},
-{"XML::Xercesc::DOMElement_getSchemaTypeInfo", _wrap_DOMElement_getSchemaTypeInfo},
-{"XML::Xercesc::delete_DOMEntity", _wrap_delete_DOMEntity},
-{"XML::Xercesc::DOMEntity_getPublicId", _wrap_DOMEntity_getPublicId},
-{"XML::Xercesc::DOMEntity_getSystemId", _wrap_DOMEntity_getSystemId},
-{"XML::Xercesc::DOMEntity_getNotationName", _wrap_DOMEntity_getNotationName},
-{"XML::Xercesc::DOMEntity_getInputEncoding", _wrap_DOMEntity_getInputEncoding},
-{"XML::Xercesc::DOMEntity_getXmlEncoding", _wrap_DOMEntity_getXmlEncoding},
-{"XML::Xercesc::DOMEntity_getXmlVersion", _wrap_DOMEntity_getXmlVersion},
-{"XML::Xercesc::delete_DOMDocumentType", _wrap_delete_DOMDocumentType},
-{"XML::Xercesc::DOMDocumentType_getName", _wrap_DOMDocumentType_getName},
-{"XML::Xercesc::DOMDocumentType_getEntities", _wrap_DOMDocumentType_getEntities},
-{"XML::Xercesc::DOMDocumentType_getNotations", _wrap_DOMDocumentType_getNotations},
-{"XML::Xercesc::DOMDocumentType_getPublicId", _wrap_DOMDocumentType_getPublicId},
-{"XML::Xercesc::DOMDocumentType_getSystemId", _wrap_DOMDocumentType_getSystemId},
-{"XML::Xercesc::DOMDocumentType_getInternalSubset", _wrap_DOMDocumentType_getInternalSubset},
-{"XML::Xercesc::delete_DOMCharacterData", _wrap_delete_DOMCharacterData},
-{"XML::Xercesc::DOMCharacterData_getData", _wrap_DOMCharacterData_getData},
-{"XML::Xercesc::DOMCharacterData_getLength", _wrap_DOMCharacterData_getLength},
-{"XML::Xercesc::DOMCharacterData_substringData", _wrap_DOMCharacterData_substringData},
-{"XML::Xercesc::DOMCharacterData_appendData", _wrap_DOMCharacterData_appendData},
-{"XML::Xercesc::DOMCharacterData_insertData", _wrap_DOMCharacterData_insertData},
-{"XML::Xercesc::DOMCharacterData_deleteData", _wrap_DOMCharacterData_deleteData},
-{"XML::Xercesc::DOMCharacterData_replaceData", _wrap_DOMCharacterData_replaceData},
-{"XML::Xercesc::DOMCharacterData_setData", _wrap_DOMCharacterData_setData},
-{"XML::Xercesc::delete_DOMComment", _wrap_delete_DOMComment},
-{"XML::Xercesc::delete_DOMText", _wrap_delete_DOMText},
-{"XML::Xercesc::DOMText_splitText", _wrap_DOMText_splitText},
-{"XML::Xercesc::DOMText_getIsElementContentWhitespace", _wrap_DOMText_getIsElementContentWhitespace},
-{"XML::Xercesc::DOMText_getWholeText", _wrap_DOMText_getWholeText},
-{"XML::Xercesc::DOMText_replaceWholeText", _wrap_DOMText_replaceWholeText},
-{"XML::Xercesc::DOMText_isIgnorableWhitespace", _wrap_DOMText_isIgnorableWhitespace},
-{"XML::Xercesc::delete_DOMCDATASection", _wrap_delete_DOMCDATASection},
-{"XML::Xercesc::delete_DOMNodeList", _wrap_delete_DOMNodeList},
-{"XML::Xercesc::DOMNodeList_item", _wrap_DOMNodeList_item},
-{"XML::Xercesc::DOMNodeList_getLength", _wrap_DOMNodeList_getLength},
-{"XML::Xercesc::delete_DOMNamedNodeMap", _wrap_delete_DOMNamedNodeMap},
-{"XML::Xercesc::DOMNamedNodeMap_setNamedItem", _wrap_DOMNamedNodeMap_setNamedItem},
-{"XML::Xercesc::DOMNamedNodeMap_item", _wrap_DOMNamedNodeMap_item},
-{"XML::Xercesc::DOMNamedNodeMap_getNamedItem", _wrap_DOMNamedNodeMap_getNamedItem},
-{"XML::Xercesc::DOMNamedNodeMap_getLength", _wrap_DOMNamedNodeMap_getLength},
-{"XML::Xercesc::DOMNamedNodeMap_removeNamedItem", _wrap_DOMNamedNodeMap_removeNamedItem},
-{"XML::Xercesc::DOMNamedNodeMap_getNamedItemNS", _wrap_DOMNamedNodeMap_getNamedItemNS},
-{"XML::Xercesc::DOMNamedNodeMap_setNamedItemNS", _wrap_DOMNamedNodeMap_setNamedItemNS},
-{"XML::Xercesc::DOMNamedNodeMap_removeNamedItemNS", _wrap_DOMNamedNodeMap_removeNamedItemNS},
-{"XML::Xercesc::delete_DOMDocumentFragment", _wrap_delete_DOMDocumentFragment},
-{"XML::Xercesc::delete_DOMEntityReference", _wrap_delete_DOMEntityReference},
-{"XML::Xercesc::delete_DOMNotation", _wrap_delete_DOMNotation},
-{"XML::Xercesc::DOMNotation_getPublicId", _wrap_DOMNotation_getPublicId},
-{"XML::Xercesc::DOMNotation_getSystemId", _wrap_DOMNotation_getSystemId},
-{"XML::Xercesc::delete_DOMProcessingInstruction", _wrap_delete_DOMProcessingInstruction},
-{"XML::Xercesc::DOMProcessingInstruction_getTarget", _wrap_DOMProcessingInstruction_getTarget},
-{"XML::Xercesc::DOMProcessingInstruction_getData", _wrap_DOMProcessingInstruction_getData},
-{"XML::Xercesc::DOMProcessingInstruction_setData", _wrap_DOMProcessingInstruction_setData},
-{"XML::Xercesc::delete_DOMTypeInfo", _wrap_delete_DOMTypeInfo},
-{"XML::Xercesc::DOMTypeInfo_getTypeName", _wrap_DOMTypeInfo_getTypeName},
-{"XML::Xercesc::DOMTypeInfo_getTypeNamespace", _wrap_DOMTypeInfo_getTypeNamespace},
-{"XML::Xercesc::DOMTypeInfo_isDerivedFrom", _wrap_DOMTypeInfo_isDerivedFrom},
-{"XML::Xercesc::delete_DOMPSVITypeInfo", _wrap_delete_DOMPSVITypeInfo},
-{"XML::Xercesc::DOMPSVITypeInfo_getStringProperty", _wrap_DOMPSVITypeInfo_getStringProperty},
-{"XML::Xercesc::DOMPSVITypeInfo_getNumericProperty", _wrap_DOMPSVITypeInfo_getNumericProperty},
-{"XML::Xercesc::delete_DOMXPathEvaluator", _wrap_delete_DOMXPathEvaluator},
-{"XML::Xercesc::DOMXPathEvaluator_createExpression", _wrap_DOMXPathEvaluator_createExpression},
-{"XML::Xercesc::DOMXPathEvaluator_createNSResolver", _wrap_DOMXPathEvaluator_createNSResolver},
-{"XML::Xercesc::DOMXPathEvaluator_evaluate", _wrap_DOMXPathEvaluator_evaluate},
-{"XML::Xercesc::new_DOMXPathException", _wrap_new_DOMXPathException},
-{"XML::Xercesc::delete_DOMXPathException", _wrap_delete_DOMXPathException},
-{"XML::Xercesc::DOMXPathException_code_set", _wrap_DOMXPathException_code_set},
-{"XML::Xercesc::DOMXPathException_code_get", _wrap_DOMXPathException_code_get},
-{"XML::Xercesc::DOMXPathException_msg_set", _wrap_DOMXPathException_msg_set},
-{"XML::Xercesc::DOMXPathException_msg_get", _wrap_DOMXPathException_msg_get},
-{"XML::Xercesc::delete_DOMXPathExpression", _wrap_delete_DOMXPathExpression},
-{"XML::Xercesc::DOMXPathExpression_evaluate", _wrap_DOMXPathExpression_evaluate},
-{"XML::Xercesc::delete_DOMXPathNamespace", _wrap_delete_DOMXPathNamespace},
-{"XML::Xercesc::DOMXPathNamespace_getOwnerElement", _wrap_DOMXPathNamespace_getOwnerElement},
-{"XML::Xercesc::delete_DOMXPathNSResolver", _wrap_delete_DOMXPathNSResolver},
-{"XML::Xercesc::DOMXPathNSResolver_lookupNamespaceURI", _wrap_DOMXPathNSResolver_lookupNamespaceURI},
-{"XML::Xercesc::DOMXPathNSResolver_lookupPrefix", _wrap_DOMXPathNSResolver_lookupPrefix},
-{"XML::Xercesc::delete_DOMXPathResult", _wrap_delete_DOMXPathResult},
-{"XML::Xercesc::DOMXPathResult_getBooleanValue", _wrap_DOMXPathResult_getBooleanValue},
-{"XML::Xercesc::DOMXPathResult_getInvalidIteratorState", _wrap_DOMXPathResult_getInvalidIteratorState},
-{"XML::Xercesc::DOMXPathResult_getNumberValue", _wrap_DOMXPathResult_getNumberValue},
-{"XML::Xercesc::DOMXPathResult_getResultType", _wrap_DOMXPathResult_getResultType},
-{"XML::Xercesc::DOMXPathResult_getSingleNodeValue", _wrap_DOMXPathResult_getSingleNodeValue},
-{"XML::Xercesc::DOMXPathResult_getSnapshotLength", _wrap_DOMXPathResult_getSnapshotLength},
-{"XML::Xercesc::DOMXPathResult_getStringValue", _wrap_DOMXPathResult_getStringValue},
-{"XML::Xercesc::DOMXPathResult_iterateNext", _wrap_DOMXPathResult_iterateNext},
-{"XML::Xercesc::DOMXPathResult_snapshotItem", _wrap_DOMXPathResult_snapshotItem},
-{"XML::Xercesc::delete_DOMDocumentRange", _wrap_delete_DOMDocumentRange},
-{"XML::Xercesc::DOMDocumentRange_createRange", _wrap_DOMDocumentRange_createRange},
-{"XML::Xercesc::delete_DOMDocumentTraversal", _wrap_delete_DOMDocumentTraversal},
-{"XML::Xercesc::DOMDocumentTraversal_createNodeIterator", _wrap_DOMDocumentTraversal_createNodeIterator},
-{"XML::Xercesc::DOMDocumentTraversal_createTreeWalker", _wrap_DOMDocumentTraversal_createTreeWalker},
-{"XML::Xercesc::delete_DOMNodeIterator", _wrap_delete_DOMNodeIterator},
-{"XML::Xercesc::DOMNodeIterator_getRoot", _wrap_DOMNodeIterator_getRoot},
-{"XML::Xercesc::DOMNodeIterator_getWhatToShow", _wrap_DOMNodeIterator_getWhatToShow},
-{"XML::Xercesc::DOMNodeIterator_getFilter", _wrap_DOMNodeIterator_getFilter},
-{"XML::Xercesc::DOMNodeIterator_getExpandEntityReferences", _wrap_DOMNodeIterator_getExpandEntityReferences},
-{"XML::Xercesc::DOMNodeIterator_nextNode", _wrap_DOMNodeIterator_nextNode},
-{"XML::Xercesc::DOMNodeIterator_previousNode", _wrap_DOMNodeIterator_previousNode},
-{"XML::Xercesc::DOMNodeIterator_detach", _wrap_DOMNodeIterator_detach},
-{"XML::Xercesc::DOMNodeIterator_release", _wrap_DOMNodeIterator_release},
-{"XML::Xercesc::delete_DOMNodeFilter", _wrap_delete_DOMNodeFilter},
-{"XML::Xercesc::DOMNodeFilter_acceptNode", _wrap_DOMNodeFilter_acceptNode},
-{"XML::Xercesc::delete_DOMRange", _wrap_delete_DOMRange},
-{"XML::Xercesc::DOMRange_getStartContainer", _wrap_DOMRange_getStartContainer},
-{"XML::Xercesc::DOMRange_getStartOffset", _wrap_DOMRange_getStartOffset},
-{"XML::Xercesc::DOMRange_getEndContainer", _wrap_DOMRange_getEndContainer},
-{"XML::Xercesc::DOMRange_getEndOffset", _wrap_DOMRange_getEndOffset},
-{"XML::Xercesc::DOMRange_getCollapsed", _wrap_DOMRange_getCollapsed},
-{"XML::Xercesc::DOMRange_getCommonAncestorContainer", _wrap_DOMRange_getCommonAncestorContainer},
-{"XML::Xercesc::DOMRange_setStart", _wrap_DOMRange_setStart},
-{"XML::Xercesc::DOMRange_setEnd", _wrap_DOMRange_setEnd},
-{"XML::Xercesc::DOMRange_setStartBefore", _wrap_DOMRange_setStartBefore},
-{"XML::Xercesc::DOMRange_setStartAfter", _wrap_DOMRange_setStartAfter},
-{"XML::Xercesc::DOMRange_setEndBefore", _wrap_DOMRange_setEndBefore},
-{"XML::Xercesc::DOMRange_setEndAfter", _wrap_DOMRange_setEndAfter},
-{"XML::Xercesc::DOMRange_collapse", _wrap_DOMRange_collapse},
-{"XML::Xercesc::DOMRange_selectNode", _wrap_DOMRange_selectNode},
-{"XML::Xercesc::DOMRange_selectNodeContents", _wrap_DOMRange_selectNodeContents},
-{"XML::Xercesc::DOMRange_compareBoundaryPoints", _wrap_DOMRange_compareBoundaryPoints},
-{"XML::Xercesc::DOMRange_deleteContents", _wrap_DOMRange_deleteContents},
-{"XML::Xercesc::DOMRange_extractContents", _wrap_DOMRange_extractContents},
-{"XML::Xercesc::DOMRange_cloneContents", _wrap_DOMRange_cloneContents},
-{"XML::Xercesc::DOMRange_insertNode", _wrap_DOMRange_insertNode},
-{"XML::Xercesc::DOMRange_surroundContents", _wrap_DOMRange_surroundContents},
-{"XML::Xercesc::DOMRange_cloneRange", _wrap_DOMRange_cloneRange},
-{"XML::Xercesc::DOMRange_toString", _wrap_DOMRange_toString},
-{"XML::Xercesc::DOMRange_detach", _wrap_DOMRange_detach},
-{"XML::Xercesc::DOMRange_release", _wrap_DOMRange_release},
-{"XML::Xercesc::new_DOMRangeException", _wrap_new_DOMRangeException},
-{"XML::Xercesc::delete_DOMRangeException", _wrap_delete_DOMRangeException},
-{"XML::Xercesc::DOMRangeException_code_set", _wrap_DOMRangeException_code_set},
-{"XML::Xercesc::DOMRangeException_code_get", _wrap_DOMRangeException_code_get},
-{"XML::Xercesc::delete_DOMTreeWalker", _wrap_delete_DOMTreeWalker},
-{"XML::Xercesc::DOMTreeWalker_getRoot", _wrap_DOMTreeWalker_getRoot},
-{"XML::Xercesc::DOMTreeWalker_getWhatToShow", _wrap_DOMTreeWalker_getWhatToShow},
-{"XML::Xercesc::DOMTreeWalker_getFilter", _wrap_DOMTreeWalker_getFilter},
-{"XML::Xercesc::DOMTreeWalker_getExpandEntityReferences", _wrap_DOMTreeWalker_getExpandEntityReferences},
-{"XML::Xercesc::DOMTreeWalker_getCurrentNode", _wrap_DOMTreeWalker_getCurrentNode},
-{"XML::Xercesc::DOMTreeWalker_parentNode", _wrap_DOMTreeWalker_parentNode},
-{"XML::Xercesc::DOMTreeWalker_firstChild", _wrap_DOMTreeWalker_firstChild},
-{"XML::Xercesc::DOMTreeWalker_lastChild", _wrap_DOMTreeWalker_lastChild},
-{"XML::Xercesc::DOMTreeWalker_previousSibling", _wrap_DOMTreeWalker_previousSibling},
-{"XML::Xercesc::DOMTreeWalker_nextSibling", _wrap_DOMTreeWalker_nextSibling},
-{"XML::Xercesc::DOMTreeWalker_previousNode", _wrap_DOMTreeWalker_previousNode},
-{"XML::Xercesc::DOMTreeWalker_nextNode", _wrap_DOMTreeWalker_nextNode},
-{"XML::Xercesc::DOMTreeWalker_setCurrentNode", _wrap_DOMTreeWalker_setCurrentNode},
-{"XML::Xercesc::DOMTreeWalker_release", _wrap_DOMTreeWalker_release},
-{"XML::Xercesc::delete_DOMUserDataHandler", _wrap_delete_DOMUserDataHandler},
-{"XML::Xercesc::DOMUserDataHandler_handle", _wrap_DOMUserDataHandler_handle},
-{"XML::Xercesc::DOMConfiguration_setParameter", _wrap_DOMConfiguration_setParameter},
-{"XML::Xercesc::DOMConfiguration_getParameter", _wrap_DOMConfiguration_getParameter},
-{"XML::Xercesc::DOMConfiguration_canSetParameter", _wrap_DOMConfiguration_canSetParameter},
-{"XML::Xercesc::DOMConfiguration_getParameterNames", _wrap_DOMConfiguration_getParameterNames},
-{"XML::Xercesc::delete_DOMConfiguration", _wrap_delete_DOMConfiguration},
-{"XML::Xercesc::delete_DOMStringList", _wrap_delete_DOMStringList},
-{"XML::Xercesc::DOMStringList_item", _wrap_DOMStringList_item},
-{"XML::Xercesc::DOMStringList_getLength", _wrap_DOMStringList_getLength},
-{"XML::Xercesc::DOMStringList_contains", _wrap_DOMStringList_contains},
-{"XML::Xercesc::DOMStringList_release", _wrap_DOMStringList_release},
-{"XML::Xercesc::delete_DOMImplementationLS", _wrap_delete_DOMImplementationLS},
-{"XML::Xercesc::DOMImplementationLS_createLSParser", _wrap_DOMImplementationLS_createLSParser},
-{"XML::Xercesc::DOMImplementationLS_createLSSerializer", _wrap_DOMImplementationLS_createLSSerializer},
-{"XML::Xercesc::DOMImplementationLS_createLSInput", _wrap_DOMImplementationLS_createLSInput},
-{"XML::Xercesc::DOMImplementationLS_createLSOutput", _wrap_DOMImplementationLS_createLSOutput},
-{"XML::Xercesc::delete_DOMImplementation", _wrap_delete_DOMImplementation},
-{"XML::Xercesc::DOMImplementation_hasFeature", _wrap_DOMImplementation_hasFeature},
-{"XML::Xercesc::DOMImplementation_createDocumentType", _wrap_DOMImplementation_createDocumentType},
-{"XML::Xercesc::DOMImplementation_getFeature", _wrap_DOMImplementation_getFeature},
-{"XML::Xercesc::DOMImplementation_createDocument", _wrap_DOMImplementation_createDocument},
-{"XML::Xercesc::DOMImplementation_getImplementation", _wrap_DOMImplementation_getImplementation},
-{"XML::Xercesc::delete_DOMImplementationList", _wrap_delete_DOMImplementationList},
-{"XML::Xercesc::DOMImplementationList_item", _wrap_DOMImplementationList_item},
-{"XML::Xercesc::DOMImplementationList_getLength", _wrap_DOMImplementationList_getLength},
-{"XML::Xercesc::DOMImplementationList_release", _wrap_DOMImplementationList_release},
-{"XML::Xercesc::delete_DOMImplementationSource", _wrap_delete_DOMImplementationSource},
-{"XML::Xercesc::DOMImplementationSource_getDOMImplementation", _wrap_DOMImplementationSource_getDOMImplementation},
-{"XML::Xercesc::DOMImplementationSource_getDOMImplementationList", _wrap_DOMImplementationSource_getDOMImplementationList},
-{"XML::Xercesc::DOMImplementationRegistry_getDOMImplementation", _wrap_DOMImplementationRegistry_getDOMImplementation},
-{"XML::Xercesc::DOMImplementationRegistry_getDOMImplementationList", _wrap_DOMImplementationRegistry_getDOMImplementationList},
-{"XML::Xercesc::DOMImplementationRegistry_addSource", _wrap_DOMImplementationRegistry_addSource},
-{"XML::Xercesc::delete_DOMImplementationRegistry", _wrap_delete_DOMImplementationRegistry},
-{"XML::Xercesc::delete_DOMError", _wrap_delete_DOMError},
-{"XML::Xercesc::DOMError_getSeverity", _wrap_DOMError_getSeverity},
-{"XML::Xercesc::DOMError_getMessage", _wrap_DOMError_getMessage},
-{"XML::Xercesc::DOMError_getLocation", _wrap_DOMError_getLocation},
-{"XML::Xercesc::DOMError_getRelatedException", _wrap_DOMError_getRelatedException},
-{"XML::Xercesc::DOMError_getType", _wrap_DOMError_getType},
-{"XML::Xercesc::DOMError_getRelatedData", _wrap_DOMError_getRelatedData},
-{"XML::Xercesc::delete_DOMErrorHandler", _wrap_delete_DOMErrorHandler},
-{"XML::Xercesc::DOMErrorHandler_handleError", _wrap_DOMErrorHandler_handleError},
-{"XML::Xercesc::delete_DOMDocument", _wrap_delete_DOMDocument},
-{"XML::Xercesc::DOMDocument_createElement", _wrap_DOMDocument_createElement},
-{"XML::Xercesc::DOMDocument_createDocumentFragment", _wrap_DOMDocument_createDocumentFragment},
-{"XML::Xercesc::DOMDocument_createTextNode", _wrap_DOMDocument_createTextNode},
-{"XML::Xercesc::DOMDocument_createComment", _wrap_DOMDocument_createComment},
-{"XML::Xercesc::DOMDocument_createCDATASection", _wrap_DOMDocument_createCDATASection},
-{"XML::Xercesc::DOMDocument_createProcessingInstruction", _wrap_DOMDocument_createProcessingInstruction},
-{"XML::Xercesc::DOMDocument_createAttribute", _wrap_DOMDocument_createAttribute},
-{"XML::Xercesc::DOMDocument_createEntityReference", _wrap_DOMDocument_createEntityReference},
-{"XML::Xercesc::DOMDocument_getDoctype", _wrap_DOMDocument_getDoctype},
-{"XML::Xercesc::DOMDocument_getImplementation", _wrap_DOMDocument_getImplementation},
-{"XML::Xercesc::DOMDocument_getDocumentElement", _wrap_DOMDocument_getDocumentElement},
-{"XML::Xercesc::DOMDocument_getElementsByTagName", _wrap_DOMDocument_getElementsByTagName},
-{"XML::Xercesc::DOMDocument_importNode", _wrap_DOMDocument_importNode},
-{"XML::Xercesc::DOMDocument_createAttributeNS", _wrap_DOMDocument_createAttributeNS},
-{"XML::Xercesc::DOMDocument_getElementsByTagNameNS", _wrap_DOMDocument_getElementsByTagNameNS},
-{"XML::Xercesc::DOMDocument_getElementById", _wrap_DOMDocument_getElementById},
-{"XML::Xercesc::DOMDocument_getInputEncoding", _wrap_DOMDocument_getInputEncoding},
-{"XML::Xercesc::DOMDocument_getXmlEncoding", _wrap_DOMDocument_getXmlEncoding},
-{"XML::Xercesc::DOMDocument_getXmlStandalone", _wrap_DOMDocument_getXmlStandalone},
-{"XML::Xercesc::DOMDocument_setXmlStandalone", _wrap_DOMDocument_setXmlStandalone},
-{"XML::Xercesc::DOMDocument_getXmlVersion", _wrap_DOMDocument_getXmlVersion},
-{"XML::Xercesc::DOMDocument_setXmlVersion", _wrap_DOMDocument_setXmlVersion},
-{"XML::Xercesc::DOMDocument_getDocumentURI", _wrap_DOMDocument_getDocumentURI},
-{"XML::Xercesc::DOMDocument_setDocumentURI", _wrap_DOMDocument_setDocumentURI},
-{"XML::Xercesc::DOMDocument_getStrictErrorChecking", _wrap_DOMDocument_getStrictErrorChecking},
-{"XML::Xercesc::DOMDocument_setStrictErrorChecking", _wrap_DOMDocument_setStrictErrorChecking},
-{"XML::Xercesc::DOMDocument_renameNode", _wrap_DOMDocument_renameNode},
-{"XML::Xercesc::DOMDocument_adoptNode", _wrap_DOMDocument_adoptNode},
-{"XML::Xercesc::DOMDocument_normalizeDocument", _wrap_DOMDocument_normalizeDocument},
-{"XML::Xercesc::DOMDocument_getDOMConfig", _wrap_DOMDocument_getDOMConfig},
-{"XML::Xercesc::DOMDocument_createEntity", _wrap_DOMDocument_createEntity},
-{"XML::Xercesc::DOMDocument_createDocumentType", _wrap_DOMDocument_createDocumentType},
-{"XML::Xercesc::DOMDocument_createNotation", _wrap_DOMDocument_createNotation},
-{"XML::Xercesc::DOMDocument_createElementNS", _wrap_DOMDocument_createElementNS},
-{"XML::Xercesc::delete_DOMLocator", _wrap_delete_DOMLocator},
-{"XML::Xercesc::DOMLocator_getLineNumber", _wrap_DOMLocator_getLineNumber},
-{"XML::Xercesc::DOMLocator_getColumnNumber", _wrap_DOMLocator_getColumnNumber},
-{"XML::Xercesc::DOMLocator_getByteOffset", _wrap_DOMLocator_getByteOffset},
-{"XML::Xercesc::DOMLocator_getUtf16Offset", _wrap_DOMLocator_getUtf16Offset},
-{"XML::Xercesc::DOMLocator_getRelatedNode", _wrap_DOMLocator_getRelatedNode},
-{"XML::Xercesc::DOMLocator_getURI", _wrap_DOMLocator_getURI},
-{"XML::Xercesc::delete_DOMLSResourceResolver", _wrap_delete_DOMLSResourceResolver},
-{"XML::Xercesc::DOMLSResourceResolver_resolveResource", _wrap_DOMLSResourceResolver_resolveResource},
-{"XML::Xercesc::delete_DOMLSInput", _wrap_delete_DOMLSInput},
-{"XML::Xercesc::DOMLSInput_getStringData", _wrap_DOMLSInput_getStringData},
-{"XML::Xercesc::DOMLSInput_getByteStream", _wrap_DOMLSInput_getByteStream},
-{"XML::Xercesc::DOMLSInput_getEncoding", _wrap_DOMLSInput_getEncoding},
-{"XML::Xercesc::DOMLSInput_getPublicId", _wrap_DOMLSInput_getPublicId},
-{"XML::Xercesc::DOMLSInput_getSystemId", _wrap_DOMLSInput_getSystemId},
-{"XML::Xercesc::DOMLSInput_getBaseURI", _wrap_DOMLSInput_getBaseURI},
-{"XML::Xercesc::DOMLSInput_setStringData", _wrap_DOMLSInput_setStringData},
-{"XML::Xercesc::DOMLSInput_setByteStream", _wrap_DOMLSInput_setByteStream},
-{"XML::Xercesc::DOMLSInput_setEncoding", _wrap_DOMLSInput_setEncoding},
-{"XML::Xercesc::DOMLSInput_setPublicId", _wrap_DOMLSInput_setPublicId},
-{"XML::Xercesc::DOMLSInput_setSystemId", _wrap_DOMLSInput_setSystemId},
-{"XML::Xercesc::DOMLSInput_setBaseURI", _wrap_DOMLSInput_setBaseURI},
-{"XML::Xercesc::DOMLSInput_setIssueFatalErrorIfNotFound", _wrap_DOMLSInput_setIssueFatalErrorIfNotFound},
-{"XML::Xercesc::DOMLSInput_getIssueFatalErrorIfNotFound", _wrap_DOMLSInput_getIssueFatalErrorIfNotFound},
-{"XML::Xercesc::DOMLSInput_release", _wrap_DOMLSInput_release},
-{"XML::Xercesc::new_Wrapper4InputSource", _wrap_new_Wrapper4InputSource},
-{"XML::Xercesc::delete_Wrapper4InputSource", _wrap_delete_Wrapper4InputSource},
-{"XML::Xercesc::Wrapper4InputSource_getStringData", _wrap_Wrapper4InputSource_getStringData},
-{"XML::Xercesc::Wrapper4InputSource_getByteStream", _wrap_Wrapper4InputSource_getByteStream},
-{"XML::Xercesc::Wrapper4InputSource_getEncoding", _wrap_Wrapper4InputSource_getEncoding},
-{"XML::Xercesc::Wrapper4InputSource_getPublicId", _wrap_Wrapper4InputSource_getPublicId},
-{"XML::Xercesc::Wrapper4InputSource_getSystemId", _wrap_Wrapper4InputSource_getSystemId},
-{"XML::Xercesc::Wrapper4InputSource_getBaseURI", _wrap_Wrapper4InputSource_getBaseURI},
-{"XML::Xercesc::Wrapper4InputSource_getIssueFatalErrorIfNotFound", _wrap_Wrapper4InputSource_getIssueFatalErrorIfNotFound},
-{"XML::Xercesc::Wrapper4InputSource_setStringData", _wrap_Wrapper4InputSource_setStringData},
-{"XML::Xercesc::Wrapper4InputSource_setByteStream", _wrap_Wrapper4InputSource_setByteStream},
-{"XML::Xercesc::Wrapper4InputSource_setEncoding", _wrap_Wrapper4InputSource_setEncoding},
-{"XML::Xercesc::Wrapper4InputSource_setPublicId", _wrap_Wrapper4InputSource_setPublicId},
-{"XML::Xercesc::Wrapper4InputSource_setSystemId", _wrap_Wrapper4InputSource_setSystemId},
-{"XML::Xercesc::Wrapper4InputSource_setBaseURI", _wrap_Wrapper4InputSource_setBaseURI},
-{"XML::Xercesc::Wrapper4InputSource_setIssueFatalErrorIfNotFound", _wrap_Wrapper4InputSource_setIssueFatalErrorIfNotFound},
-{"XML::Xercesc::Wrapper4InputSource_release", _wrap_Wrapper4InputSource_release},
-{"XML::Xercesc::new_Wrapper4DOMLSInput", _wrap_new_Wrapper4DOMLSInput},
-{"XML::Xercesc::delete_Wrapper4DOMLSInput", _wrap_delete_Wrapper4DOMLSInput},
-{"XML::Xercesc::Wrapper4DOMLSInput_makeStream", _wrap_Wrapper4DOMLSInput_makeStream},
-{"XML::Xercesc::Wrapper4DOMLSInput_getEncoding", _wrap_Wrapper4DOMLSInput_getEncoding},
-{"XML::Xercesc::Wrapper4DOMLSInput_getPublicId", _wrap_Wrapper4DOMLSInput_getPublicId},
-{"XML::Xercesc::Wrapper4DOMLSInput_getSystemId", _wrap_Wrapper4DOMLSInput_getSystemId},
-{"XML::Xercesc::Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound", _wrap_Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound},
-{"XML::Xercesc::Wrapper4DOMLSInput_setEncoding", _wrap_Wrapper4DOMLSInput_setEncoding},
-{"XML::Xercesc::Wrapper4DOMLSInput_setPublicId", _wrap_Wrapper4DOMLSInput_setPublicId},
-{"XML::Xercesc::Wrapper4DOMLSInput_setSystemId", _wrap_Wrapper4DOMLSInput_setSystemId},
-{"XML::Xercesc::Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound", _wrap_Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound},
-{"XML::Xercesc::delete_DOMLSParser", _wrap_delete_DOMLSParser},
-{"XML::Xercesc::DOMLSParser_getDomConfig", _wrap_DOMLSParser_getDomConfig},
-{"XML::Xercesc::DOMLSParser_getAsync", _wrap_DOMLSParser_getAsync},
-{"XML::Xercesc::DOMLSParser_getBusy", _wrap_DOMLSParser_getBusy},
-{"XML::Xercesc::DOMLSParser_setFilter", _wrap_DOMLSParser_setFilter},
-{"XML::Xercesc::DOMLSParser_parse", _wrap_DOMLSParser_parse},
-{"XML::Xercesc::DOMLSParser_parseURI", _wrap_DOMLSParser_parseURI},
-{"XML::Xercesc::DOMLSParser_parseWithContext", _wrap_DOMLSParser_parseWithContext},
-{"XML::Xercesc::DOMLSParser_abort", _wrap_DOMLSParser_abort},
-{"XML::Xercesc::DOMLSParser_release", _wrap_DOMLSParser_release},
-{"XML::Xercesc::DOMLSParser_resetDocumentPool", _wrap_DOMLSParser_resetDocumentPool},
-{"XML::Xercesc::DOMLSParser_loadGrammar", _wrap_DOMLSParser_loadGrammar},
-{"XML::Xercesc::DOMLSParser_getGrammar", _wrap_DOMLSParser_getGrammar},
-{"XML::Xercesc::DOMLSParser_getRootGrammar", _wrap_DOMLSParser_getRootGrammar},
-{"XML::Xercesc::DOMLSParser_getURIText", _wrap_DOMLSParser_getURIText},
-{"XML::Xercesc::DOMLSParser_resetCachedGrammarPool", _wrap_DOMLSParser_resetCachedGrammarPool},
-{"XML::Xercesc::DOMLSParser_getSrcOffset", _wrap_DOMLSParser_getSrcOffset},
-{"XML::Xercesc::delete_DOMLSOutput", _wrap_delete_DOMLSOutput},
-{"XML::Xercesc::DOMLSOutput_getByteStream", _wrap_DOMLSOutput_getByteStream},
-{"XML::Xercesc::DOMLSOutput_getEncoding", _wrap_DOMLSOutput_getEncoding},
-{"XML::Xercesc::DOMLSOutput_getSystemId", _wrap_DOMLSOutput_getSystemId},
-{"XML::Xercesc::DOMLSOutput_setByteStream", _wrap_DOMLSOutput_setByteStream},
-{"XML::Xercesc::DOMLSOutput_setEncoding", _wrap_DOMLSOutput_setEncoding},
-{"XML::Xercesc::DOMLSOutput_setSystemId", _wrap_DOMLSOutput_setSystemId},
-{"XML::Xercesc::DOMLSOutput_release", _wrap_DOMLSOutput_release},
-{"XML::Xercesc::new_StdOutFormatTarget", _wrap_new_StdOutFormatTarget},
-{"XML::Xercesc::delete_StdOutFormatTarget", _wrap_delete_StdOutFormatTarget},
-{"XML::Xercesc::StdOutFormatTarget_writeChars", _wrap_StdOutFormatTarget_writeChars},
-{"XML::Xercesc::StdOutFormatTarget_flush", _wrap_StdOutFormatTarget_flush},
-{"XML::Xercesc::new_LocalFileFormatTarget", _wrap_new_LocalFileFormatTarget},
-{"XML::Xercesc::delete_LocalFileFormatTarget", _wrap_delete_LocalFileFormatTarget},
-{"XML::Xercesc::LocalFileFormatTarget_writeChars", _wrap_LocalFileFormatTarget_writeChars},
-{"XML::Xercesc::LocalFileFormatTarget_flush", _wrap_LocalFileFormatTarget_flush},
-{"XML::Xercesc::new_MemBufFormatTarget", _wrap_new_MemBufFormatTarget},
-{"XML::Xercesc::delete_MemBufFormatTarget", _wrap_delete_MemBufFormatTarget},
-{"XML::Xercesc::MemBufFormatTarget_writeChars", _wrap_MemBufFormatTarget_writeChars},
-{"XML::Xercesc::MemBufFormatTarget_getRawBuffer", _wrap_MemBufFormatTarget_getRawBuffer},
-{"XML::Xercesc::MemBufFormatTarget_getLen", _wrap_MemBufFormatTarget_getLen},
-{"XML::Xercesc::MemBufFormatTarget_reset", _wrap_MemBufFormatTarget_reset},
-{"XML::Xercesc::new_DOMLSException", _wrap_new_DOMLSException},
-{"XML::Xercesc::delete_DOMLSException", _wrap_delete_DOMLSException},
-{"XML::Xercesc::DOMLSException_getMessage", _wrap_DOMLSException_getMessage},
-{"XML::Xercesc::DOMLSException_code_set", _wrap_DOMLSException_code_set},
-{"XML::Xercesc::DOMLSException_code_get", _wrap_DOMLSException_code_get},
-{"XML::Xercesc::DOMLSException_msg_set", _wrap_DOMLSException_msg_set},
-{"XML::Xercesc::DOMLSException_msg_get", _wrap_DOMLSException_msg_get},
-{"XML::Xercesc::delete_DOMLSSerializer", _wrap_delete_DOMLSSerializer},
-{"XML::Xercesc::DOMLSSerializer_getDomConfig", _wrap_DOMLSSerializer_getDomConfig},
-{"XML::Xercesc::DOMLSSerializer_setNewLine", _wrap_DOMLSSerializer_setNewLine},
-{"XML::Xercesc::DOMLSSerializer_setFilter", _wrap_DOMLSSerializer_setFilter},
-{"XML::Xercesc::DOMLSSerializer_getNewLine", _wrap_DOMLSSerializer_getNewLine},
-{"XML::Xercesc::DOMLSSerializer_write", _wrap_DOMLSSerializer_write},
-{"XML::Xercesc::DOMLSSerializer_writeToURI", _wrap_DOMLSSerializer_writeToURI},
-{"XML::Xercesc::DOMLSSerializer_writeToString", _wrap_DOMLSSerializer_writeToString},
-{"XML::Xercesc::DOMLSSerializer_release", _wrap_DOMLSSerializer_release},
-{"XML::Xercesc::delete_DOMLSSerializerFilter", _wrap_delete_DOMLSSerializerFilter},
-{"XML::Xercesc::DOMLSSerializerFilter_acceptNode", _wrap_DOMLSSerializerFilter_acceptNode},
-{"XML::Xercesc::DOMLSSerializerFilter_getWhatToShow", _wrap_DOMLSSerializerFilter_getWhatToShow},
{"XML::Xercesc::delete_SAXException", _wrap_delete_SAXException},
{"XML::Xercesc::SAXException_getMessage", _wrap_SAXException_getMessage},
{"XML::Xercesc::new_SAXNotSupportedException", _wrap_new_SAXNotSupportedException},
@@ -69838,90 +44152,6 @@ static swig_command_info swig_commands[] = {
{"XML::Xercesc::PSVIHandler_handleElementPSVI", _wrap_PSVIHandler_handleElementPSVI},
{"XML::Xercesc::PSVIHandler_handlePartialElementPSVI", _wrap_PSVIHandler_handlePartialElementPSVI},
{"XML::Xercesc::PSVIHandler_handleAttributesPSVI", _wrap_PSVIHandler_handleAttributesPSVI},
-{"XML::Xercesc::delete_AbstractDOMParser", _wrap_delete_AbstractDOMParser},
-{"XML::Xercesc::AbstractDOMParser_reset", _wrap_AbstractDOMParser_reset},
-{"XML::Xercesc::AbstractDOMParser_adoptDocument", _wrap_AbstractDOMParser_adoptDocument},
-{"XML::Xercesc::AbstractDOMParser_getDocument", _wrap_AbstractDOMParser_getDocument},
-{"XML::Xercesc::AbstractDOMParser_getValidator", _wrap_AbstractDOMParser_getValidator},
-{"XML::Xercesc::AbstractDOMParser_getValidationScheme", _wrap_AbstractDOMParser_getValidationScheme},
-{"XML::Xercesc::AbstractDOMParser_getDoSchema", _wrap_AbstractDOMParser_getDoSchema},
-{"XML::Xercesc::AbstractDOMParser_getValidationSchemaFullChecking", _wrap_AbstractDOMParser_getValidationSchemaFullChecking},
-{"XML::Xercesc::AbstractDOMParser_getIdentityConstraintChecking", _wrap_AbstractDOMParser_getIdentityConstraintChecking},
-{"XML::Xercesc::AbstractDOMParser_getErrorCount", _wrap_AbstractDOMParser_getErrorCount},
-{"XML::Xercesc::AbstractDOMParser_getDoNamespaces", _wrap_AbstractDOMParser_getDoNamespaces},
-{"XML::Xercesc::AbstractDOMParser_getExitOnFirstFatalError", _wrap_AbstractDOMParser_getExitOnFirstFatalError},
-{"XML::Xercesc::AbstractDOMParser_getValidationConstraintFatal", _wrap_AbstractDOMParser_getValidationConstraintFatal},
-{"XML::Xercesc::AbstractDOMParser_getCreateEntityReferenceNodes", _wrap_AbstractDOMParser_getCreateEntityReferenceNodes},
-{"XML::Xercesc::AbstractDOMParser_getIncludeIgnorableWhitespace", _wrap_AbstractDOMParser_getIncludeIgnorableWhitespace},
-{"XML::Xercesc::AbstractDOMParser_getExternalSchemaLocation", _wrap_AbstractDOMParser_getExternalSchemaLocation},
-{"XML::Xercesc::AbstractDOMParser_getExternalNoNamespaceSchemaLocation", _wrap_AbstractDOMParser_getExternalNoNamespaceSchemaLocation},
-{"XML::Xercesc::AbstractDOMParser_getSecurityManager", _wrap_AbstractDOMParser_getSecurityManager},
-{"XML::Xercesc::AbstractDOMParser_getLoadExternalDTD", _wrap_AbstractDOMParser_getLoadExternalDTD},
-{"XML::Xercesc::AbstractDOMParser_getCreateCommentNodes", _wrap_AbstractDOMParser_getCreateCommentNodes},
-{"XML::Xercesc::AbstractDOMParser_getCalculateSrcOfs", _wrap_AbstractDOMParser_getCalculateSrcOfs},
-{"XML::Xercesc::AbstractDOMParser_getStandardUriConformant", _wrap_AbstractDOMParser_getStandardUriConformant},
-{"XML::Xercesc::AbstractDOMParser_getPSVIHandler", _wrap_AbstractDOMParser_getPSVIHandler},
-{"XML::Xercesc::AbstractDOMParser_getCreateSchemaInfo", _wrap_AbstractDOMParser_getCreateSchemaInfo},
-{"XML::Xercesc::AbstractDOMParser_getGenerateSyntheticAnnotations", _wrap_AbstractDOMParser_getGenerateSyntheticAnnotations},
-{"XML::Xercesc::AbstractDOMParser_getValidateAnnotations", _wrap_AbstractDOMParser_getValidateAnnotations},
-{"XML::Xercesc::AbstractDOMParser_getIgnoreAnnotations", _wrap_AbstractDOMParser_getIgnoreAnnotations},
-{"XML::Xercesc::AbstractDOMParser_getDisableDefaultEntityResolution", _wrap_AbstractDOMParser_getDisableDefaultEntityResolution},
-{"XML::Xercesc::AbstractDOMParser_getSkipDTDValidation", _wrap_AbstractDOMParser_getSkipDTDValidation},
-{"XML::Xercesc::AbstractDOMParser_setGenerateSyntheticAnnotations", _wrap_AbstractDOMParser_setGenerateSyntheticAnnotations},
-{"XML::Xercesc::AbstractDOMParser_setValidateAnnotations", _wrap_AbstractDOMParser_setValidateAnnotations},
-{"XML::Xercesc::AbstractDOMParser_setDoNamespaces", _wrap_AbstractDOMParser_setDoNamespaces},
-{"XML::Xercesc::AbstractDOMParser_setExitOnFirstFatalError", _wrap_AbstractDOMParser_setExitOnFirstFatalError},
-{"XML::Xercesc::AbstractDOMParser_setValidationConstraintFatal", _wrap_AbstractDOMParser_setValidationConstraintFatal},
-{"XML::Xercesc::AbstractDOMParser_setCreateEntityReferenceNodes", _wrap_AbstractDOMParser_setCreateEntityReferenceNodes},
-{"XML::Xercesc::AbstractDOMParser_setIncludeIgnorableWhitespace", _wrap_AbstractDOMParser_setIncludeIgnorableWhitespace},
-{"XML::Xercesc::AbstractDOMParser_setValidationScheme", _wrap_AbstractDOMParser_setValidationScheme},
-{"XML::Xercesc::AbstractDOMParser_setDoSchema", _wrap_AbstractDOMParser_setDoSchema},
-{"XML::Xercesc::AbstractDOMParser_setValidationSchemaFullChecking", _wrap_AbstractDOMParser_setValidationSchemaFullChecking},
-{"XML::Xercesc::AbstractDOMParser_setIdentityConstraintChecking", _wrap_AbstractDOMParser_setIdentityConstraintChecking},
-{"XML::Xercesc::AbstractDOMParser_setExternalSchemaLocation", _wrap_AbstractDOMParser_setExternalSchemaLocation},
-{"XML::Xercesc::AbstractDOMParser_setExternalNoNamespaceSchemaLocation", _wrap_AbstractDOMParser_setExternalNoNamespaceSchemaLocation},
-{"XML::Xercesc::AbstractDOMParser_setSecurityManager", _wrap_AbstractDOMParser_setSecurityManager},
-{"XML::Xercesc::AbstractDOMParser_setLoadExternalDTD", _wrap_AbstractDOMParser_setLoadExternalDTD},
-{"XML::Xercesc::AbstractDOMParser_setCreateCommentNodes", _wrap_AbstractDOMParser_setCreateCommentNodes},
-{"XML::Xercesc::AbstractDOMParser_setCalculateSrcOfs", _wrap_AbstractDOMParser_setCalculateSrcOfs},
-{"XML::Xercesc::AbstractDOMParser_setStandardUriConformant", _wrap_AbstractDOMParser_setStandardUriConformant},
-{"XML::Xercesc::AbstractDOMParser_useScanner", _wrap_AbstractDOMParser_useScanner},
-{"XML::Xercesc::AbstractDOMParser_useImplementation", _wrap_AbstractDOMParser_useImplementation},
-{"XML::Xercesc::AbstractDOMParser_setPSVIHandler", _wrap_AbstractDOMParser_setPSVIHandler},
-{"XML::Xercesc::AbstractDOMParser_setCreateSchemaInfo", _wrap_AbstractDOMParser_setCreateSchemaInfo},
-{"XML::Xercesc::AbstractDOMParser_setIgnoreAnnotations", _wrap_AbstractDOMParser_setIgnoreAnnotations},
-{"XML::Xercesc::AbstractDOMParser_setDisableDefaultEntityResolution", _wrap_AbstractDOMParser_setDisableDefaultEntityResolution},
-{"XML::Xercesc::AbstractDOMParser_setSkipDTDValidation", _wrap_AbstractDOMParser_setSkipDTDValidation},
-{"XML::Xercesc::AbstractDOMParser_parse", _wrap_AbstractDOMParser_parse},
-{"XML::Xercesc::AbstractDOMParser_parseFirst", _wrap_AbstractDOMParser_parseFirst},
-{"XML::Xercesc::AbstractDOMParser_parseNext", _wrap_AbstractDOMParser_parseNext},
-{"XML::Xercesc::AbstractDOMParser_parseReset", _wrap_AbstractDOMParser_parseReset},
-{"XML::Xercesc::AbstractDOMParser_handleElementPSVI", _wrap_AbstractDOMParser_handleElementPSVI},
-{"XML::Xercesc::AbstractDOMParser_handlePartialElementPSVI", _wrap_AbstractDOMParser_handlePartialElementPSVI},
-{"XML::Xercesc::AbstractDOMParser_handleAttributesPSVI", _wrap_AbstractDOMParser_handleAttributesPSVI},
-{"XML::Xercesc::new_XercesDOMParser", _wrap_new_XercesDOMParser},
-{"XML::Xercesc::delete_XercesDOMParser", _wrap_delete_XercesDOMParser},
-{"XML::Xercesc::XercesDOMParser_getErrorHandler", _wrap_XercesDOMParser_getErrorHandler},
-{"XML::Xercesc::XercesDOMParser_getEntityResolver", _wrap_XercesDOMParser_getEntityResolver},
-{"XML::Xercesc::XercesDOMParser_getXMLEntityResolver", _wrap_XercesDOMParser_getXMLEntityResolver},
-{"XML::Xercesc::XercesDOMParser_isCachingGrammarFromParse", _wrap_XercesDOMParser_isCachingGrammarFromParse},
-{"XML::Xercesc::XercesDOMParser_isUsingCachedGrammarInParse", _wrap_XercesDOMParser_isUsingCachedGrammarInParse},
-{"XML::Xercesc::XercesDOMParser_getGrammar", _wrap_XercesDOMParser_getGrammar},
-{"XML::Xercesc::XercesDOMParser_getRootGrammar", _wrap_XercesDOMParser_getRootGrammar},
-{"XML::Xercesc::XercesDOMParser_getURIText", _wrap_XercesDOMParser_getURIText},
-{"XML::Xercesc::XercesDOMParser_getSrcOffset", _wrap_XercesDOMParser_getSrcOffset},
-{"XML::Xercesc::XercesDOMParser_getIgnoreCachedDTD", _wrap_XercesDOMParser_getIgnoreCachedDTD},
-{"XML::Xercesc::XercesDOMParser_setErrorHandler", _wrap_XercesDOMParser_setErrorHandler},
-{"XML::Xercesc::XercesDOMParser_setEntityResolver", _wrap_XercesDOMParser_setEntityResolver},
-{"XML::Xercesc::XercesDOMParser_setXMLEntityResolver", _wrap_XercesDOMParser_setXMLEntityResolver},
-{"XML::Xercesc::XercesDOMParser_cacheGrammarFromParse", _wrap_XercesDOMParser_cacheGrammarFromParse},
-{"XML::Xercesc::XercesDOMParser_useCachedGrammarInParse", _wrap_XercesDOMParser_useCachedGrammarInParse},
-{"XML::Xercesc::XercesDOMParser_setIgnoreCachedDTD", _wrap_XercesDOMParser_setIgnoreCachedDTD},
-{"XML::Xercesc::XercesDOMParser_resetDocumentPool", _wrap_XercesDOMParser_resetDocumentPool},
-{"XML::Xercesc::XercesDOMParser_error", _wrap_XercesDOMParser_error},
-{"XML::Xercesc::XercesDOMParser_resetErrors", _wrap_XercesDOMParser_resetErrors},
-{"XML::Xercesc::XercesDOMParser_loadGrammar", _wrap_XercesDOMParser_loadGrammar},
-{"XML::Xercesc::XercesDOMParser_resetCachedGrammarPool", _wrap_XercesDOMParser_resetCachedGrammarPool},
{"XML::Xercesc::delete_Parser", _wrap_delete_Parser},
{"XML::Xercesc::Parser_setEntityResolver", _wrap_Parser_setEntityResolver},
{"XML::Xercesc::Parser_setDTDHandler", _wrap_Parser_setDTDHandler},
@@ -70041,7 +44271,6 @@ static swig_command_info swig_commands[] = {
{"XML::Xercesc::delete_PerlCallbackHandler", _wrap_delete_PerlCallbackHandler},
{"XML::Xercesc::PerlCallbackHandler_type", _wrap_PerlCallbackHandler_type},
{"XML::Xercesc::PerlCallbackHandler_set_callback_obj", _wrap_PerlCallbackHandler_set_callback_obj},
-{"XML::Xercesc::PerlCallbackHandler_XMLString2Perl", _wrap_PerlCallbackHandler_XMLString2Perl},
{"XML::Xercesc::new_PerlErrorCallbackHandler", _wrap_new_PerlErrorCallbackHandler},
{"XML::Xercesc::delete_PerlErrorCallbackHandler", _wrap_delete_PerlErrorCallbackHandler},
{"XML::Xercesc::PerlErrorCallbackHandler_type", _wrap_PerlErrorCallbackHandler_type},
@@ -70049,10 +44278,6 @@ static swig_command_info swig_commands[] = {
{"XML::Xercesc::new_PerlEntityResolverHandler", _wrap_new_PerlEntityResolverHandler},
{"XML::Xercesc::delete_PerlEntityResolverHandler", _wrap_delete_PerlEntityResolverHandler},
{"XML::Xercesc::PerlEntityResolverHandler_type", _wrap_PerlEntityResolverHandler_type},
-{"XML::Xercesc::new_PerlNodeFilterCallbackHandler", _wrap_new_PerlNodeFilterCallbackHandler},
-{"XML::Xercesc::delete_PerlNodeFilterCallbackHandler", _wrap_delete_PerlNodeFilterCallbackHandler},
-{"XML::Xercesc::PerlNodeFilterCallbackHandler_type", _wrap_PerlNodeFilterCallbackHandler_type},
-{"XML::Xercesc::PerlNodeFilterCallbackHandler_acceptNode", _wrap_PerlNodeFilterCallbackHandler_acceptNode},
{"XML::Xercesc::new_PerlDocumentCallbackHandler", _wrap_new_PerlDocumentCallbackHandler},
{"XML::Xercesc::delete_PerlDocumentCallbackHandler", _wrap_delete_PerlDocumentCallbackHandler},
{"XML::Xercesc::PerlDocumentCallbackHandler_type", _wrap_PerlDocumentCallbackHandler_type},
@@ -70339,9 +44564,6 @@ XS(SWIG_init) {
SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar->dcast = (swig_dycast_func) Grammar_dynamic_cast;
-
- SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode->dcast = (swig_dycast_func) DOMNode_dynamic_cast;
-
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDeleter, (void*) "XML::Xerces::XMLDeleter");
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPlatformUtils, (void*) "XML::Xerces::XMLPlatformUtils");
/*@SWIG:%set_constant@*/ do {
@@ -72784,581 +47006,6 @@ XS(SWIG_init) {
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdInInputSource, (void*) "XML::Xerces::StdInInputSource");
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource, (void*) "XML::Xerces::URLInputSource");
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufInputSource, (void*) "XML::Xerces::MemBufInputSource");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_INDEX_SIZE_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INDEX_SIZE_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_DOMSTRING_SIZE_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::DOMSTRING_SIZE_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_HIERARCHY_REQUEST_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::HIERARCHY_REQUEST_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_WRONG_DOCUMENT_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::WRONG_DOCUMENT_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_INVALID_CHARACTER_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INVALID_CHARACTER_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_NO_DATA_ALLOWED_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::NO_DATA_ALLOWED_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_NO_MODIFICATION_ALLOWED_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::NO_MODIFICATION_ALLOWED_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_NOT_FOUND_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::NOT_FOUND_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_NOT_SUPPORTED_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::NOT_SUPPORTED_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_INUSE_ATTRIBUTE_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INUSE_ATTRIBUTE_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_INVALID_STATE_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INVALID_STATE_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_SYNTAX_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::SYNTAX_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_INVALID_MODIFICATION_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INVALID_MODIFICATION_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_NAMESPACE_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::NAMESPACE_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_INVALID_ACCESS_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::INVALID_ACCESS_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_VALIDATION_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::VALIDATION_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMException_TYPE_MISMATCH_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMException::TYPE_MISMATCH_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException, (void*) "XML::Xerces::DOMException");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_ELEMENT_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::ELEMENT_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_ATTRIBUTE_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::ATTRIBUTE_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_TEXT_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::TEXT_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_CDATA_SECTION_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::CDATA_SECTION_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_ENTITY_REFERENCE_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::ENTITY_REFERENCE_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_ENTITY_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::ENTITY_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_PROCESSING_INSTRUCTION_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::PROCESSING_INSTRUCTION_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_COMMENT_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::COMMENT_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_TYPE_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_TYPE_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_FRAGMENT_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_FRAGMENT_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_NOTATION_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::NOTATION_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_DISCONNECTED", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_DISCONNECTED)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_PRECEDING", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_PRECEDING)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_FOLLOWING", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_FOLLOWING)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_CONTAINS", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_CONTAINS)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_CONTAINED_BY", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_CONTAINED_BY)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNode_DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void*) "XML::Xerces::DOMNode");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr, (void*) "XML::Xerces::DOMAttr");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement, (void*) "XML::Xerces::DOMElement");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity, (void*) "XML::Xerces::DOMEntity");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType, (void*) "XML::Xerces::DOMDocumentType");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData, (void*) "XML::Xerces::DOMCharacterData");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment, (void*) "XML::Xerces::DOMComment");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText, (void*) "XML::Xerces::DOMText");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection, (void*) "XML::Xerces::DOMCDATASection");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList, (void*) "XML::Xerces::DOMNodeList");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, (void*) "XML::Xerces::DOMNamedNodeMap");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, (void*) "XML::Xerces::DOMDocumentFragment");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference, (void*) "XML::Xerces::DOMEntityReference");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation, (void*) "XML::Xerces::DOMNotation");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, (void*) "XML::Xerces::DOMProcessingInstruction");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMTypeInfo_DERIVATION_RESTRICTION", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMTypeInfo::DERIVATION_RESTRICTION)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMTypeInfo_DERIVATION_EXTENSION", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMTypeInfo::DERIVATION_EXTENSION)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMTypeInfo_DERIVATION_UNION", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMTypeInfo::DERIVATION_UNION)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMTypeInfo_DERIVATION_LIST", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMTypeInfo::DERIVATION_LIST)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo, (void*) "XML::Xerces::DOMTypeInfo");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Validity", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Validity)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Validitation_Attempted", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Validitation_Attempted)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Type_Definition_Type", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Type_Definition_Type)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Type_Definition_Name", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Type_Definition_Name)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Type_Definition_Namespace", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Type_Definition_Namespace)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Type_Definition_Anonymous", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Nil", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Nil)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Member_Type_Definition_Name", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Member_Type_Definition_Name)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Member_Type_Definition_Namespace", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Member_Type_Definition_Namespace)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Member_Type_Definition_Anonymous", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Member_Type_Definition_Anonymous)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Schema_Default", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Schema_Default)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Schema_Normalized_Value", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Schema_Normalized_Value)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMPSVITypeInfo_PSVI_Schema_Specified", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMPSVITypeInfo::PSVI_Schema_Specified)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMPSVITypeInfo, (void*) "XML::Xerces::DOMPSVITypeInfo");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathEvaluator, (void*) "XML::Xerces::DOMXPathEvaluator");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathException_INVALID_EXPRESSION_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathException::INVALID_EXPRESSION_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathException_TYPE_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathException::TYPE_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathException, (void*) "XML::Xerces::DOMXPathException");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathExpression, (void*) "XML::Xerces::DOMXPathExpression");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathNamespace_XPATH_NAMESPACE_NODE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathNamespace::XPATH_NAMESPACE_NODE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNamespace, (void*) "XML::Xerces::DOMXPathNamespace");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathNSResolver, (void*) "XML::Xerces::DOMXPathNSResolver");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_ANY_TYPE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::ANY_TYPE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_NUMBER_TYPE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::NUMBER_TYPE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_STRING_TYPE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::STRING_TYPE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_BOOLEAN_TYPE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::BOOLEAN_TYPE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_UNORDERED_NODE_ITERATOR_TYPE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::UNORDERED_NODE_ITERATOR_TYPE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_ORDERED_NODE_ITERATOR_TYPE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::ORDERED_NODE_ITERATOR_TYPE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_UNORDERED_NODE_SNAPSHOT_TYPE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::UNORDERED_NODE_SNAPSHOT_TYPE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_ORDERED_NODE_SNAPSHOT_TYPE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_ANY_UNORDERED_NODE_TYPE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::ANY_UNORDERED_NODE_TYPE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMXPathResult_FIRST_ORDERED_NODE_TYPE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMXPathResult::FIRST_ORDERED_NODE_TYPE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMXPathResult, (void*) "XML::Xerces::DOMXPathResult");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentRange, (void*) "XML::Xerces::DOMDocumentRange");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentTraversal, (void*) "XML::Xerces::DOMDocumentTraversal");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeIterator, (void*) "XML::Xerces::DOMNodeIterator");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_FILTER_ACCEPT", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::FILTER_ACCEPT)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_FILTER_REJECT", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::FILTER_REJECT)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_FILTER_SKIP", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::FILTER_SKIP)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_ALL", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_ALL)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_ELEMENT", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_ELEMENT)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_ATTRIBUTE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_ATTRIBUTE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_TEXT", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_TEXT)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_CDATA_SECTION", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_CDATA_SECTION)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_ENTITY_REFERENCE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_ENTITY_REFERENCE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_ENTITY", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_ENTITY)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_PROCESSING_INSTRUCTION", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_PROCESSING_INSTRUCTION)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_COMMENT", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_COMMENT)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_DOCUMENT", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_DOCUMENT)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_DOCUMENT_TYPE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_DOCUMENT_TYPE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_DOCUMENT_FRAGMENT", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_DOCUMENT_FRAGMENT)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMNodeFilter_SHOW_NOTATION", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMNodeFilter::SHOW_NOTATION)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeFilter, (void*) "XML::Xerces::DOMNodeFilter");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMRange_START_TO_START", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRange::START_TO_START)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMRange_START_TO_END", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRange::START_TO_END)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMRange_END_TO_END", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRange::END_TO_END)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMRange_END_TO_START", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRange::END_TO_START)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRange, (void*) "XML::Xerces::DOMRange");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMRangeException_BAD_BOUNDARYPOINTS_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRangeException::BAD_BOUNDARYPOINTS_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMRangeException_INVALID_NODE_TYPE_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMRangeException::INVALID_NODE_TYPE_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMRangeException, (void*) "XML::Xerces::DOMRangeException");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTreeWalker, (void*) "XML::Xerces::DOMTreeWalker");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMUserDataHandler_NODE_CLONED", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMUserDataHandler::NODE_CLONED)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMUserDataHandler_NODE_IMPORTED", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMUserDataHandler::NODE_IMPORTED)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMUserDataHandler_NODE_DELETED", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMUserDataHandler::NODE_DELETED)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMUserDataHandler_NODE_RENAMED", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMUserDataHandler::NODE_RENAMED)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMUserDataHandler_NODE_ADOPTED", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMUserDataHandler::NODE_ADOPTED)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler, (void*) "XML::Xerces::DOMUserDataHandler");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMConfiguration, (void*) "XML::Xerces::DOMConfiguration");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMStringList, (void*) "XML::Xerces::DOMStringList");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMImplementationLS_MODE_SYNCHRONOUS", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMImplementationLS::MODE_SYNCHRONOUS)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMImplementationLS_MODE_ASYNCHRONOUS", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMImplementationLS::MODE_ASYNCHRONOUS)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationLS, (void*) "XML::Xerces::DOMImplementationLS");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementation, (void*) "XML::Xerces::DOMImplementation");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationList, (void*) "XML::Xerces::DOMImplementationList");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationSource, (void*) "XML::Xerces::DOMImplementationSource");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMImplementationRegistry, (void*) "XML::Xerces::DOMImplementationRegistry");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMError_DOM_SEVERITY_WARNING", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMError::DOM_SEVERITY_WARNING)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMError_DOM_SEVERITY_ERROR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMError::DOM_SEVERITY_ERROR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMError_DOM_SEVERITY_FATAL_ERROR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMError::DOM_SEVERITY_FATAL_ERROR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMError, (void*) "XML::Xerces::DOMError");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMErrorHandler, (void*) "XML::Xerces::DOMErrorHandler");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument, (void*) "XML::Xerces::DOMDocument");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLocator, (void*) "XML::Xerces::DOMLocator");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSResourceResolver, (void*) "XML::Xerces::DOMLSResourceResolver");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSInput, (void*) "XML::Xerces::DOMLSInput");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4InputSource, (void*) "XML::Xerces::Wrapper4InputSource");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Wrapper4DOMLSInput, (void*) "XML::Xerces::Wrapper4DOMLSInput");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMLSParser_ACTION_APPEND_AS_CHILDREN", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSParser::ACTION_APPEND_AS_CHILDREN)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMLSParser_ACTION_REPLACE_CHILDREN", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSParser::ACTION_REPLACE_CHILDREN)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMLSParser_ACTION_INSERT_BEFORE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSParser::ACTION_INSERT_BEFORE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMLSParser_ACTION_INSERT_AFTER", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSParser::ACTION_INSERT_AFTER)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMLSParser_ACTION_REPLACE", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSParser::ACTION_REPLACE)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSParser, (void*) "XML::Xerces::DOMLSParser");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSOutput, (void*) "XML::Xerces::DOMLSOutput");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget, (void*) "XML::Xerces::StdOutFormatTarget");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget, (void*) "XML::Xerces::LocalFileFormatTarget");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget, (void*) "XML::Xerces::MemBufFormatTarget");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMLSException_PARSE_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSException::PARSE_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "DOMLSException_SERIALIZE_ERR", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::DOMLSException::SERIALIZE_ERR)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSException, (void*) "XML::Xerces::DOMLSException");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializer, (void*) "XML::Xerces::DOMLSSerializer");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMLSSerializerFilter, (void*) "XML::Xerces::DOMLSSerializerFilter");
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException, (void*) "XML::Xerces::SAXException");
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, (void*) "XML::Xerces::SAXNotSupportedException");
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException, (void*) "XML::Xerces::SAXNotRecognizedException");
@@ -73377,23 +47024,6 @@ XS(SWIG_init) {
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DefaultHandler, (void*) "XML::Xerces::DefaultHandler");
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken, (void*) "XML::Xerces::XMLPScanToken");
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler, (void*) "XML::Xerces::PSVIHandler");
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "AbstractDOMParser_Val_Never", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::AbstractDOMParser::Val_Never)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "AbstractDOMParser_Val_Always", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::AbstractDOMParser::Val_Always)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- /*@SWIG:%set_constant@*/ do {
- SV *sv = get_sv((char*) SWIG_prefix "AbstractDOMParser_Val_Auto", TRUE | 0x2);
- sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::AbstractDOMParser::Val_Auto)));
- SvREADONLY_on(sv);
- } while(0) /*@SWIG@*/;
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__AbstractDOMParser, (void*) "XML::Xerces::AbstractDOMParser");
- SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__XercesDOMParser, (void*) "XML::Xerces::XercesDOMParser");
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Parser, (void*) "XML::Xerces::Parser");
/*@SWIG:%set_constant@*/ do {
SV *sv = get_sv((char*) SWIG_prefix "SAXParser_Val_Never", TRUE | 0x2);
@@ -73428,6 +47058,20 @@ XS(SWIG_init) {
} while(0) /*@SWIG@*/;
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, (void*) "XML::Xerces::SAX2XMLReader");
SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLReaderFactory, (void*) "XML::Xerces::XMLReaderFactory");
+
+ // we create the global transcoder for UTF-8 to UTF-16
+ // must initialize the Xerces-C transcoding service
+ XMLPlatformUtils::Initialize();
+ UTF8_TRANSCODER = Transcoder::getInstance();
+ if (! UTF8_TRANSCODER) {
+ croak("ERROR: XML::Xerces: INIT: Could not create UTF-8 transcoder");
+ }
+
+ XML_EXCEPTION_HANDLER = XMLExceptionHandler::getInstance();
+ if (! XML_EXCEPTION_HANDLER) {
+ croak("ERROR: XML::Xerces: INIT: Could not create XMLExceptionHandler");
+ }
+
/*@SWIG:%set_constant@*/ do {
SV *sv = get_sv((char*) SWIG_prefix "PERLCALLBACKHANDLER_BASE_TYPE", TRUE | 0x2);
sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(-1)));
@@ -73461,23 +47105,8 @@ XS(SWIG_init) {
SWIG_TypeClientData(SWIGTYPE_p_PerlCallbackHandler, (void*) "XML::Xerces::PerlCallbackHandler");
SWIG_TypeClientData(SWIGTYPE_p_PerlErrorCallbackHandler, (void*) "XML::Xerces::PerlErrorCallbackHandler");
SWIG_TypeClientData(SWIGTYPE_p_PerlEntityResolverHandler, (void*) "XML::Xerces::PerlEntityResolverHandler");
- SWIG_TypeClientData(SWIGTYPE_p_PerlNodeFilterCallbackHandler, (void*) "XML::Xerces::PerlNodeFilterCallbackHandler");
SWIG_TypeClientData(SWIGTYPE_p_PerlDocumentCallbackHandler, (void*) "XML::Xerces::PerlDocumentCallbackHandler");
SWIG_TypeClientData(SWIGTYPE_p_PerlContentCallbackHandler, (void*) "XML::Xerces::PerlContentCallbackHandler");
-
- // we create the global transcoder for UTF-8 to UTF-16
- XMLTransService::Codes failReason;
- XMLPlatformUtils::Initialize(); // first we must create the transservice
- UTF8_ENCODING = XMLString::transcode("UTF-8");
- UTF8_TRANSCODER =
- XMLPlatformUtils::fgTransService->makeNewTranscoderFor(UTF8_ENCODING,
- failReason,
- 1024,
- XMLPlatformUtils::fgMemoryManager);
- if (! UTF8_TRANSCODER) {
- croak("ERROR: XML::Xerces: INIT: Could not create UTF-8 transcoder");
- }
-
ST(0) = &PL_sv_yes;
XSRETURN(1);
}
diff --git a/swig/perl/Xerces.pm b/swig/perl/Xerces.pm
index a4d43f578..f756bc497 100644
--- a/swig/perl/Xerces.pm
+++ b/swig/perl/Xerces.pm
@@ -19,6 +19,7 @@
package XML::Xerces;
require Exporter;
require DynaLoader;
+use vars qw(@ISA);
@ISA = qw(Exporter DynaLoader);
package XML::Xercesc;
bootstrap XML::Xerces;
@@ -30,7 +31,7 @@ use strict;
use Carp;
use vars qw(@EXPORT_OK $VERSION %REMEMBER);
@EXPORT_OK = qw(error);
-$VERSION = 260.2;
+$VERSION = 300.060829;
#
# Cleanup removes all objects being remembered by an object
@@ -656,28 +657,6 @@ sub to_hash {
return %hash;
}
-package XML::Xerces::DOMNodeList;
-# convert the NodeList to a perl list
-sub to_list {
- my $self = shift;
- my @list;
- for (my $i=0;$i<$self->getLength();$i++) {
- push(@list,$self->item($i));
- }
- return @list;
-}
-
-package XML::Xerces::DOMStringList;
-# convert the StringList to a perl list
-sub to_list {
- my $self = shift;
- my @list;
- for (my $i=0;$i<$self->getLength();$i++) {
- push(@list,$self->item($i));
- }
- return @list;
-}
-
package XML::Xerces::Attributes;
sub to_hash {
my $self = shift;
@@ -702,186 +681,6 @@ sub to_hash {
return %hash;
}
-package XML::Xerces::DOMNamedNodeMap;
-# convert the NamedNodeMap to a perl hash
-sub to_hash {
- my $self = shift;
- my @list;
- for (my $i=0;$i<$self->getLength();$i++) {
- my $node = $self->item($i);
- push(@list, $node->to_hash());
- }
- return @list;
-}
-
-package XML::Xerces::DOMNode;
-sub to_hash {
- my $self = shift;
- return ($self->getNodeName,$self->getNodeValue);
-}
-
-sub quote_content {
- my ($self,$node_value) = @_;
-
- $node_value =~ s/&/&/g;
- $node_value =~ s/</</g;
- $node_value =~ s/>/>/g;
- $node_value =~ s/\"/"/g;
- $node_value =~ s/\'/'/g;
-
- return $node_value;
-}
-
-package XML::Xerces::DOMEntity;
-sub to_hash {
- my $self = shift;
- if ($self->hasChildNodes) {
- return ($self->getNodeName(),
- $self->getFirstChild->getNodeValue());
- } else {
- return ($self->getNodeName(), '');
- }
-}
-
-package XML::Xerces::DOMText;
-sub serialize {
- return $_[0]->quote_content($_[0]->getNodeValue);
-}
-
-package XML::Xerces::DOMProcessingInstruction;
-sub serialize {
- my $output .= '<?' . $_[0]->getNodeName;
- if (length(my $str = $_[0]->getNodeValue)) {
- $output .= " $str";
- }
- $output .= '?>';
- return $output;
-}
-
-package XML::Xerces::DOMDocument;
-sub serialize {
- my $output;
- my $indent = 2;
- for(my $child = $_[0]->getFirstChild() ;
- defined $child ;
- $child = $child->getNextSibling())
- {
- $output .= $child->serialize($indent);
- }
- return "$output\n";
-}
-
-package XML::Xerces::DOMElement;
-sub serialize {
- my ($self,$indent) = @_;
- $indent ||= 0;
- my $output;
- ELEMENT: {
- my $node_name = $self->getNodeName;
- $output .= "<$node_name";
-
- my $attributes = $self->getAttributes;
- my $attribute_count = $attributes->getLength;
-
- for(my $ix = 0 ; $ix < $attribute_count ; ++$ix) {
- my $attribute = $attributes->item($ix);
- $output .= ' ' . $attribute->getNodeName . '="' . $self->quote_content($attribute->getNodeValue) . '"';
- }
-
- my $child = $self->getFirstChild();
- if (!defined $child) {
- $output .= '/>';
- last ELEMENT;
- }
-
- $output .= '>';
- while (defined $child) {
- $output .= $child->serialize($indent+2);
- $child = $child->getNextSibling();
- }
- $output .= "</$node_name>";
- }
- return $output;
-}
-
-package XML::Xerces::DOMEntityReference;
-sub serialize {
- my ($self) = @_;
- my $output;
- for(my $child = $self->getFirstChild() ;
- defined $child;
- $child = $child->getNextSibling())
- {
- $output .= $child->serialize();
- }
- return $output;
-}
-
-package XML::Xerces::DOMCDATASection;
-sub serialize {
- return '<![CDATA[' . $_[0]->getNodeValue . ']]>';
-}
-
-package XML::Xerces::DOMComment;
-sub serialize {
- return '<!--' . $_[0]->getNodeValue . "-->\n";
-}
-
-package XML::Xerces::DOMDocumentType;
-sub serialize {
- my $output;
- $output .= '<!DOCTYPE ' . $_[0]->getNodeName;
-
- my $id;
- if ($id = $_[0]->getPublicId) {
- $output .= qq[ PUBLIC "$id"];
- if ($id = $_[0]->getSystemId) {
- $output .= qq[ "$id"];
- }
- } elsif ($id = $_[0]->getSystemId) {
- $output .= qq[ SYSTEM "$id"];
- }
-
- if ($id = $_[0]->getInternalSubset) {
- $output .= " [$id]";
- }
-
- $output .= ">\n";
- return $output;
-}
-
-package XML::Xerces::DOMEntity;
-sub serialize {
- my $output;
- $output .= '<!ENTITY ' . $_[0]->getNodeName;
-
- my $id;
- if ($id = $_[0]->getPublicId) { $output .= qq[ PUBLIC "$id"]; }
- if ($id = $_[0]->getSystemId) { $output .= qq[ SYSTEM "$id"]; }
- if ($id = $_[0]->getNotationName) { $output .= qq[ NDATA "$id"]; }
-
- $output .= '>';
- return $output;
-}
-
-package XML::Xerces::DOMException;
-sub getMessage {
- return shift->{msg};
-}
-
-sub getCode {
- return shift->{code};
-}
-
-# in previous versions we needed to define this method
-# but it is now obsolete
-package XML::Xerces::DOMElement;
-sub get_text {
- my $self = shift;
- warn "XML::Xerces::DOMElement::get_text is depricated, use getTextContent instead";
- return $self->getTextContent(@_);
-}
-
package XML::Xerces::XMLCatalogResolver;
use strict;
use Carp;
@@ -3391,52 +3190,25 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMException ##############
+############# Class : XML::Xerces::SAXException ##############
-package XML::Xerces::DOMException;
+package XML::Xerces::SAXException;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( XML::Xerces );
%OWNER = ();
%ITERATORS = ();
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_DOMException(@_);
- bless $self, $pkg if defined($self);
-}
-
sub DESTROY {
return unless $_[0]->isa('HASH');
my $self = tied(%{$_[0]});
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMException($self);
+ XML::Xercesc::delete_SAXException($self);
delete $OWNER{$self};
}
}
-*INDEX_SIZE_ERR = *XML::Xercesc::DOMException_INDEX_SIZE_ERR;
-*DOMSTRING_SIZE_ERR = *XML::Xercesc::DOMException_DOMSTRING_SIZE_ERR;
-*HIERARCHY_REQUEST_ERR = *XML::Xercesc::DOMException_HIERARCHY_REQUEST_ERR;
-*WRONG_DOCUMENT_ERR = *XML::Xercesc::DOMException_WRONG_DOCUMENT_ERR;
-*INVALID_CHARACTER_ERR = *XML::Xercesc::DOMException_INVALID_CHARACTER_ERR;
-*NO_DATA_ALLOWED_ERR = *XML::Xercesc::DOMException_NO_DATA_ALLOWED_ERR;
-*NO_MODIFICATION_ALLOWED_ERR = *XML::Xercesc::DOMException_NO_MODIFICATION_ALLOWED_ERR;
-*NOT_FOUND_ERR = *XML::Xercesc::DOMException_NOT_FOUND_ERR;
-*NOT_SUPPORTED_ERR = *XML::Xercesc::DOMException_NOT_SUPPORTED_ERR;
-*INUSE_ATTRIBUTE_ERR = *XML::Xercesc::DOMException_INUSE_ATTRIBUTE_ERR;
-*INVALID_STATE_ERR = *XML::Xercesc::DOMException_INVALID_STATE_ERR;
-*SYNTAX_ERR = *XML::Xercesc::DOMException_SYNTAX_ERR;
-*INVALID_MODIFICATION_ERR = *XML::Xercesc::DOMException_INVALID_MODIFICATION_ERR;
-*NAMESPACE_ERR = *XML::Xercesc::DOMException_NAMESPACE_ERR;
-*INVALID_ACCESS_ERR = *XML::Xercesc::DOMException_INVALID_ACCESS_ERR;
-*VALIDATION_ERR = *XML::Xercesc::DOMException_VALIDATION_ERR;
-*TYPE_MISMATCH_ERR = *XML::Xercesc::DOMException_TYPE_MISMATCH_ERR;
-*getMessage = *XML::Xercesc::DOMException_getMessage;
-*swig_code_get = *XML::Xercesc::DOMException_code_get;
-*swig_code_set = *XML::Xercesc::DOMException_code_set;
-*swig_msg_get = *XML::Xercesc::DOMException_msg_get;
-*swig_msg_set = *XML::Xercesc::DOMException_msg_set;
+*getMessage = *XML::Xercesc::SAXException_getMessage;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -3450,103 +3222,30 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMNode ##############
+############# Class : XML::Xerces::SAXNotSupportedException ##############
-package XML::Xerces::DOMNode;
-use overload
- "!=" => sub { $_[0]->__ne__($_[1])},
- "==" => sub { $_[0]->__eq__($_[1])},
- "fallback" => 1;
+package XML::Xerces::SAXNotSupportedException;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
+@ISA = qw( XML::Xerces::SAXException XML::Xerces );
%OWNER = ();
%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_SAXNotSupportedException(@_);
+ bless $self, $pkg if defined($self);
+}
+
sub DESTROY {
return unless $_[0]->isa('HASH');
my $self = tied(%{$_[0]});
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMNode($self);
+ XML::Xercesc::delete_SAXNotSupportedException($self);
delete $OWNER{$self};
}
}
-*ELEMENT_NODE = *XML::Xercesc::DOMNode_ELEMENT_NODE;
-*ATTRIBUTE_NODE = *XML::Xercesc::DOMNode_ATTRIBUTE_NODE;
-*TEXT_NODE = *XML::Xercesc::DOMNode_TEXT_NODE;
-*CDATA_SECTION_NODE = *XML::Xercesc::DOMNode_CDATA_SECTION_NODE;
-*ENTITY_REFERENCE_NODE = *XML::Xercesc::DOMNode_ENTITY_REFERENCE_NODE;
-*ENTITY_NODE = *XML::Xercesc::DOMNode_ENTITY_NODE;
-*PROCESSING_INSTRUCTION_NODE = *XML::Xercesc::DOMNode_PROCESSING_INSTRUCTION_NODE;
-*COMMENT_NODE = *XML::Xercesc::DOMNode_COMMENT_NODE;
-*DOCUMENT_NODE = *XML::Xercesc::DOMNode_DOCUMENT_NODE;
-*DOCUMENT_TYPE_NODE = *XML::Xercesc::DOMNode_DOCUMENT_TYPE_NODE;
-*DOCUMENT_FRAGMENT_NODE = *XML::Xercesc::DOMNode_DOCUMENT_FRAGMENT_NODE;
-*NOTATION_NODE = *XML::Xercesc::DOMNode_NOTATION_NODE;
-*DOCUMENT_POSITION_DISCONNECTED = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_DISCONNECTED;
-*DOCUMENT_POSITION_PRECEDING = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_PRECEDING;
-*DOCUMENT_POSITION_FOLLOWING = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_FOLLOWING;
-*DOCUMENT_POSITION_CONTAINS = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_CONTAINS;
-*DOCUMENT_POSITION_CONTAINED_BY = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_CONTAINED_BY;
-*DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = *XML::Xercesc::DOMNode_DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
-*getNodeName = *XML::Xercesc::DOMNode_getNodeName;
-*getNodeValue = *XML::Xercesc::DOMNode_getNodeValue;
-*getNodeType = *XML::Xercesc::DOMNode_getNodeType;
-*getParentNode = *XML::Xercesc::DOMNode_getParentNode;
-sub getChildNodes {
- my $result = XML::Xercesc::DOMNode_getChildNodes (@_);
- unless (defined$result) {
- return () if wantarray;
- return undef;#if *not* wantarray
- }
- return $result->to_list() if wantarray;
- return $result;#if *not* wantarray
-}
-
-*getFirstChild = *XML::Xercesc::DOMNode_getFirstChild;
-*getLastChild = *XML::Xercesc::DOMNode_getLastChild;
-*getPreviousSibling = *XML::Xercesc::DOMNode_getPreviousSibling;
-*getNextSibling = *XML::Xercesc::DOMNode_getNextSibling;
-sub getAttributes {
- my $result = XML::Xercesc::DOMNode_getAttributes (@_);
- unless (defined$result) {
- return () if wantarray;
- return undef;#if *not* wantarray
- }
- return $result->to_hash() if wantarray;
- return $result;#if *not* wantarray
-}
-
-*getOwnerDocument = *XML::Xercesc::DOMNode_getOwnerDocument;
-*cloneNode = *XML::Xercesc::DOMNode_cloneNode;
-*insertBefore = *XML::Xercesc::DOMNode_insertBefore;
-*replaceChild = *XML::Xercesc::DOMNode_replaceChild;
-*removeChild = *XML::Xercesc::DOMNode_removeChild;
-*appendChild = *XML::Xercesc::DOMNode_appendChild;
-*hasChildNodes = *XML::Xercesc::DOMNode_hasChildNodes;
-*setNodeValue = *XML::Xercesc::DOMNode_setNodeValue;
-*normalize = *XML::Xercesc::DOMNode_normalize;
-*isSupported = *XML::Xercesc::DOMNode_isSupported;
-*getNamespaceURI = *XML::Xercesc::DOMNode_getNamespaceURI;
-*getLocalName = *XML::Xercesc::DOMNode_getLocalName;
-*setPrefix = *XML::Xercesc::DOMNode_setPrefix;
-*hasAttributes = *XML::Xercesc::DOMNode_hasAttributes;
-*isSameNode = *XML::Xercesc::DOMNode_isSameNode;
-*isEqualNode = *XML::Xercesc::DOMNode_isEqualNode;
-*setUserData = *XML::Xercesc::DOMNode_setUserData;
-*getUserData = *XML::Xercesc::DOMNode_getUserData;
-*getBaseURI = *XML::Xercesc::DOMNode_getBaseURI;
-*compareDocumentPosition = *XML::Xercesc::DOMNode_compareDocumentPosition;
-*getTextContent = *XML::Xercesc::DOMNode_getTextContent;
-*setTextContent = *XML::Xercesc::DOMNode_setTextContent;
-*lookupPrefix = *XML::Xercesc::DOMNode_lookupPrefix;
-*isDefaultNamespace = *XML::Xercesc::DOMNode_isDefaultNamespace;
-*lookupNamespaceURI = *XML::Xercesc::DOMNode_lookupNamespaceURI;
-*getFeature = *XML::Xercesc::DOMNode_getFeature;
-*release = *XML::Xercesc::DOMNode_release;
-*__eq__ = *XML::Xercesc::DOMNode___eq__;
-*__ne__ = *XML::Xercesc::DOMNode___ne__;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -3560,31 +3259,30 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMAttr ##############
+############# Class : XML::Xerces::SAXNotRecognizedException ##############
-package XML::Xerces::DOMAttr;
+package XML::Xerces::SAXNotRecognizedException;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+@ISA = qw( XML::Xerces::SAXException XML::Xerces );
%OWNER = ();
%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_SAXNotRecognizedException(@_);
+ bless $self, $pkg if defined($self);
+}
+
sub DESTROY {
return unless $_[0]->isa('HASH');
my $self = tied(%{$_[0]});
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMAttr($self);
+ XML::Xercesc::delete_SAXNotRecognizedException($self);
delete $OWNER{$self};
}
}
-*getName = *XML::Xercesc::DOMAttr_getName;
-*getSpecified = *XML::Xercesc::DOMAttr_getSpecified;
-*getValue = *XML::Xercesc::DOMAttr_getValue;
-*setValue = *XML::Xercesc::DOMAttr_setValue;
-*getOwnerElement = *XML::Xercesc::DOMAttr_getOwnerElement;
-*isId = *XML::Xercesc::DOMAttr_isId;
-*getSchemaTypeInfo = *XML::Xercesc::DOMAttr_getSchemaTypeInfo;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -3598,11 +3296,11 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMElement ##############
+############# Class : XML::Xerces::SAXParseException ##############
-package XML::Xerces::DOMElement;
+package XML::Xerces::SAXParseException;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+@ISA = qw( XML::Xerces::SAXException XML::Xerces );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
@@ -3611,49 +3309,15 @@ sub DESTROY {
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMElement($self);
+ XML::Xercesc::delete_SAXParseException($self);
delete $OWNER{$self};
}
}
-*getTagName = *XML::Xercesc::DOMElement_getTagName;
-*getAttribute = *XML::Xercesc::DOMElement_getAttribute;
-*getAttributeNode = *XML::Xercesc::DOMElement_getAttributeNode;
-sub getElementsByTagName {
- my $result = XML::Xercesc::DOMElement_getElementsByTagName (@_);
- unless (defined$result) {
- return () if wantarray;
- return undef;#if *not* wantarray
- }
- return $result->to_list() if wantarray;
- return $result;#if *not* wantarray
-}
-
-*setAttribute = *XML::Xercesc::DOMElement_setAttribute;
-*setAttributeNode = *XML::Xercesc::DOMElement_setAttributeNode;
-*removeAttributeNode = *XML::Xercesc::DOMElement_removeAttributeNode;
-*removeAttribute = *XML::Xercesc::DOMElement_removeAttribute;
-*getAttributeNS = *XML::Xercesc::DOMElement_getAttributeNS;
-*setAttributeNS = *XML::Xercesc::DOMElement_setAttributeNS;
-*removeAttributeNS = *XML::Xercesc::DOMElement_removeAttributeNS;
-*getAttributeNodeNS = *XML::Xercesc::DOMElement_getAttributeNodeNS;
-*setAttributeNodeNS = *XML::Xercesc::DOMElement_setAttributeNodeNS;
-sub getElementsByTagNameNS {
- my $result = XML::Xercesc::DOMElement_getElementsByTagNameNS (@_);
- unless (defined$result) {
- return () if wantarray;
- return undef;#if *not* wantarray
- }
- return $result->to_list() if wantarray;
- return $result;#if *not* wantarray
-}
-
-*hasAttribute = *XML::Xercesc::DOMElement_hasAttribute;
-*hasAttributeNS = *XML::Xercesc::DOMElement_hasAttributeNS;
-*setIdAttribute = *XML::Xercesc::DOMElement_setIdAttribute;
-*setIdAttributeNS = *XML::Xercesc::DOMElement_setIdAttributeNS;
-*setIdAttributeNode = *XML::Xercesc::DOMElement_setIdAttributeNode;
-*getSchemaTypeInfo = *XML::Xercesc::DOMElement_getSchemaTypeInfo;
+*getColumnNumber = *XML::Xercesc::SAXParseException_getColumnNumber;
+*getLineNumber = *XML::Xercesc::SAXParseException_getLineNumber;
+*getPublicId = *XML::Xercesc::SAXParseException_getPublicId;
+*getSystemId = *XML::Xercesc::SAXParseException_getSystemId;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -3667,11 +3331,11 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMEntity ##############
+############# Class : XML::Xerces::ErrorHandler ##############
-package XML::Xerces::DOMEntity;
+package XML::Xerces::ErrorHandler;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+@ISA = qw( XML::Xerces );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
@@ -3680,17 +3344,15 @@ sub DESTROY {
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMEntity($self);
+ XML::Xercesc::delete_ErrorHandler($self);
delete $OWNER{$self};
}
}
-*getPublicId = *XML::Xercesc::DOMEntity_getPublicId;
-*getSystemId = *XML::Xercesc::DOMEntity_getSystemId;
-*getNotationName = *XML::Xercesc::DOMEntity_getNotationName;
-*getInputEncoding = *XML::Xercesc::DOMEntity_getInputEncoding;
-*getXmlEncoding = *XML::Xercesc::DOMEntity_getXmlEncoding;
-*getXmlVersion = *XML::Xercesc::DOMEntity_getXmlVersion;
+*warning = *XML::Xercesc::ErrorHandler_warning;
+*error = *XML::Xercesc::ErrorHandler_error;
+*fatalError = *XML::Xercesc::ErrorHandler_fatalError;
+*resetErrors = *XML::Xercesc::ErrorHandler_resetErrors;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -3704,11 +3366,11 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMDocumentType ##############
+############# Class : XML::Xerces::DTDHandler ##############
-package XML::Xerces::DOMDocumentType;
+package XML::Xerces::DTDHandler;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+@ISA = qw( XML::Xerces );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
@@ -3717,35 +3379,12 @@ sub DESTROY {
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMDocumentType($self);
+ XML::Xercesc::delete_DTDHandler($self);
delete $OWNER{$self};
}
}
-*getName = *XML::Xercesc::DOMDocumentType_getName;
-sub getEntities {
- my $result = XML::Xercesc::DOMDocumentType_getEntities (@_);
- unless (defined$result) {
- return () if wantarray;
- return undef;#if *not* wantarray
- }
- return $result->to_hash() if wantarray;
- return $result;#if *not* wantarray
-}
-
-sub getNotations {
- my $result = XML::Xercesc::DOMDocumentType_getNotations (@_);
- unless (defined$result) {
- return () if wantarray;
- return undef;#if *not* wantarray
- }
- return $result->to_hash() if wantarray;
- return $result;#if *not* wantarray
-}
-
-*getPublicId = *XML::Xercesc::DOMDocumentType_getPublicId;
-*getSystemId = *XML::Xercesc::DOMDocumentType_getSystemId;
-*getInternalSubset = *XML::Xercesc::DOMDocumentType_getInternalSubset;
+*unparsedEntityDecl = *XML::Xercesc::DTDHandler_unparsedEntityDecl;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -3759,11 +3398,11 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMCharacterData ##############
+############# Class : XML::Xerces::DocumentHandler ##############
-package XML::Xerces::DOMCharacterData;
+package XML::Xerces::DocumentHandler;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+@ISA = qw( XML::Xerces );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
@@ -3772,19 +3411,14 @@ sub DESTROY {
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMCharacterData($self);
+ XML::Xercesc::delete_DocumentHandler($self);
delete $OWNER{$self};
}
}
-*getData = *XML::Xercesc::DOMCharacterData_getData;
-*getLength = *XML::Xercesc::DOMCharacterData_getLength;
-*substringData = *XML::Xercesc::DOMCharacterData_substringData;
-*appendData = *XML::Xercesc::DOMCharacterData_appendData;
-*insertData = *XML::Xercesc::DOMCharacterData_insertData;
-*deleteData = *XML::Xercesc::DOMCharacterData_deleteData;
-*replaceData = *XML::Xercesc::DOMCharacterData_replaceData;
-*setData = *XML::Xercesc::DOMCharacterData_setData;
+*characters = *XML::Xercesc::DocumentHandler_characters;
+*processingInstruction = *XML::Xercesc::DocumentHandler_processingInstruction;
+*setDocumentLocator = *XML::Xercesc::DocumentHandler_setDocumentLocator;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -3798,11 +3432,11 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMComment ##############
+############# Class : XML::Xerces::EntityResolver ##############
-package XML::Xerces::DOMComment;
+package XML::Xerces::EntityResolver;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMCharacterData XML::Xerces );
+@ISA = qw( XML::Xerces );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
@@ -3811,7 +3445,7 @@ sub DESTROY {
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMComment($self);
+ XML::Xercesc::delete_EntityResolver($self);
delete $OWNER{$self};
}
}
@@ -3829,11 +3463,11 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMText ##############
+############# Class : XML::Xerces::AttributeList ##############
-package XML::Xerces::DOMText;
+package XML::Xerces::AttributeList;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMCharacterData XML::Xerces );
+@ISA = qw( XML::Xerces );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
@@ -3842,16 +3476,15 @@ sub DESTROY {
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMText($self);
+ XML::Xercesc::delete_AttributeList($self);
delete $OWNER{$self};
}
}
-*splitText = *XML::Xercesc::DOMText_splitText;
-*getIsElementContentWhitespace = *XML::Xercesc::DOMText_getIsElementContentWhitespace;
-*getWholeText = *XML::Xercesc::DOMText_getWholeText;
-*replaceWholeText = *XML::Xercesc::DOMText_replaceWholeText;
-*isIgnorableWhitespace = *XML::Xercesc::DOMText_isIgnorableWhitespace;
+*getLength = *XML::Xercesc::AttributeList_getLength;
+*getName = *XML::Xercesc::AttributeList_getName;
+*getType = *XML::Xercesc::AttributeList_getType;
+*getValue = *XML::Xercesc::AttributeList_getValue;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -3865,20 +3498,34 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMCDATASection ##############
+############# Class : XML::Xerces::HandlerBase ##############
-package XML::Xerces::DOMCDATASection;
+package XML::Xerces::HandlerBase;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMText XML::Xerces );
+@ISA = qw( XML::Xerces::EntityResolver XML::Xerces::DTDHandler XML::Xerces::DocumentHandler XML::Xerces::ErrorHandler XML::Xerces );
%OWNER = ();
%ITERATORS = ();
+*characters = *XML::Xercesc::HandlerBase_characters;
+*processingInstruction = *XML::Xercesc::HandlerBase_processingInstruction;
+*setDocumentLocator = *XML::Xercesc::HandlerBase_setDocumentLocator;
+*error = *XML::Xercesc::HandlerBase_error;
+*fatalError = *XML::Xercesc::HandlerBase_fatalError;
+*warning = *XML::Xercesc::HandlerBase_warning;
+*resetErrors = *XML::Xercesc::HandlerBase_resetErrors;
+*unparsedEntityDecl = *XML::Xercesc::HandlerBase_unparsedEntityDecl;
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_HandlerBase(@_);
+ bless $self, $pkg if defined($self);
+}
+
sub DESTROY {
return unless $_[0]->isa('HASH');
my $self = tied(%{$_[0]});
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMCDATASection($self);
+ XML::Xercesc::delete_HandlerBase($self);
delete $OWNER{$self};
}
}
@@ -3896,9 +3543,9 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMNodeList ##############
+############# Class : XML::Xerces::Locator ##############
-package XML::Xerces::DOMNodeList;
+package XML::Xerces::Locator;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( XML::Xerces );
%OWNER = ();
@@ -3909,13 +3556,15 @@ sub DESTROY {
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMNodeList($self);
+ XML::Xercesc::delete_Locator($self);
delete $OWNER{$self};
}
}
-*item = *XML::Xercesc::DOMNodeList_item;
-*getLength = *XML::Xercesc::DOMNodeList_getLength;
+*getPublicId = *XML::Xercesc::Locator_getPublicId;
+*getSystemId = *XML::Xercesc::Locator_getSystemId;
+*getLineNumber = *XML::Xercesc::Locator_getLineNumber;
+*getColumnNumber = *XML::Xercesc::Locator_getColumnNumber;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -3929,9 +3578,9 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMNamedNodeMap ##############
+############# Class : XML::Xerces::Attributes ##############
-package XML::Xerces::DOMNamedNodeMap;
+package XML::Xerces::Attributes;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( XML::Xerces );
%OWNER = ();
@@ -3942,19 +3591,18 @@ sub DESTROY {
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMNamedNodeMap($self);
+ XML::Xercesc::delete_Attributes($self);
delete $OWNER{$self};
}
}
-*setNamedItem = *XML::Xercesc::DOMNamedNodeMap_setNamedItem;
-*item = *XML::Xercesc::DOMNamedNodeMap_item;
-*getNamedItem = *XML::Xercesc::DOMNamedNodeMap_getNamedItem;
-*getLength = *XML::Xercesc::DOMNamedNodeMap_getLength;
-*removeNamedItem = *XML::Xercesc::DOMNamedNodeMap_removeNamedItem;
-*getNamedItemNS = *XML::Xercesc::DOMNamedNodeMap_getNamedItemNS;
-*setNamedItemNS = *XML::Xercesc::DOMNamedNodeMap_setNamedItemNS;
-*removeNamedItemNS = *XML::Xercesc::DOMNamedNodeMap_removeNamedItemNS;
+*getLength = *XML::Xercesc::Attributes_getLength;
+*getURI = *XML::Xercesc::Attributes_getURI;
+*getLocalName = *XML::Xercesc::Attributes_getLocalName;
+*getQName = *XML::Xercesc::Attributes_getQName;
+*getIndex = *XML::Xercesc::Attributes_getIndex;
+*getType = *XML::Xercesc::Attributes_getType;
+*getValue = *XML::Xercesc::Attributes_getValue;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -3968,11 +3616,11 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMDocumentFragment ##############
+############# Class : XML::Xerces::ContentHandler ##############
-package XML::Xerces::DOMDocumentFragment;
+package XML::Xerces::ContentHandler;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+@ISA = qw( XML::Xerces );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
@@ -3981,11 +3629,17 @@ sub DESTROY {
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMDocumentFragment($self);
+ XML::Xercesc::delete_ContentHandler($self);
delete $OWNER{$self};
}
}
+*characters = *XML::Xercesc::ContentHandler_characters;
+*processingInstruction = *XML::Xercesc::ContentHandler_processingInstruction;
+*setDocumentLocator = *XML::Xercesc::ContentHandler_setDocumentLocator;
+*startPrefixMapping = *XML::Xercesc::ContentHandler_startPrefixMapping;
+*endPrefixMapping = *XML::Xercesc::ContentHandler_endPrefixMapping;
+*skippedEntity = *XML::Xercesc::ContentHandler_skippedEntity;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -3999,11 +3653,11 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMEntityReference ##############
+############# Class : XML::Xerces::LexicalHandler ##############
-package XML::Xerces::DOMEntityReference;
+package XML::Xerces::LexicalHandler;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+@ISA = qw( XML::Xerces );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
@@ -4012,11 +3666,18 @@ sub DESTROY {
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMEntityReference($self);
+ XML::Xercesc::delete_LexicalHandler($self);
delete $OWNER{$self};
}
}
+*comment = *XML::Xercesc::LexicalHandler_comment;
+*endCDATA = *XML::Xercesc::LexicalHandler_endCDATA;
+*endDTD = *XML::Xercesc::LexicalHandler_endDTD;
+*endEntity = *XML::Xercesc::LexicalHandler_endEntity;
+*startCDATA = *XML::Xercesc::LexicalHandler_startCDATA;
+*startDTD = *XML::Xercesc::LexicalHandler_startDTD;
+*startEntity = *XML::Xercesc::LexicalHandler_startEntity;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -4030,11 +3691,11 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMNotation ##############
+############# Class : XML::Xerces::DeclHandler ##############
-package XML::Xerces::DOMNotation;
+package XML::Xerces::DeclHandler;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+@ISA = qw( XML::Xerces );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
@@ -4043,13 +3704,14 @@ sub DESTROY {
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMNotation($self);
+ XML::Xercesc::delete_DeclHandler($self);
delete $OWNER{$self};
}
}
-*getPublicId = *XML::Xercesc::DOMNotation_getPublicId;
-*getSystemId = *XML::Xercesc::DOMNotation_getSystemId;
+*attributeDecl = *XML::Xercesc::DeclHandler_attributeDecl;
+*internalEntityDecl = *XML::Xercesc::DeclHandler_internalEntityDecl;
+*externalEntityDecl = *XML::Xercesc::DeclHandler_externalEntityDecl;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -4063,2249 +3725,47 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::DOMProcessingInstruction ##############
+############# Class : XML::Xerces::DefaultHandler ##############
-package XML::Xerces::DOMProcessingInstruction;
+package XML::Xerces::DefaultHandler;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
+@ISA = qw( XML::Xerces::EntityResolver XML::Xerces::DTDHandler XML::Xerces::ContentHandler XML::Xerces::ErrorHandler XML::Xerces::LexicalHandler XML::Xerces::DeclHandler XML::Xerces );
%OWNER = ();
%ITERATORS = ();
+*characters = *XML::Xercesc::DefaultHandler_characters;
+*processingInstruction = *XML::Xercesc::DefaultHandler_processingInstruction;
+*setDocumentLocator = *XML::Xercesc::DefaultHandler_setDocumentLocator;
+*startPrefixMapping = *XML::Xercesc::DefaultHandler_startPrefixMapping;
+*endPrefixMapping = *XML::Xercesc::DefaultHandler_endPrefixMapping;
+*skippedEntity = *XML::Xercesc::DefaultHandler_skippedEntity;
+*error = *XML::Xercesc::DefaultHandler_error;
+*fatalError = *XML::Xercesc::DefaultHandler_fatalError;
+*warning = *XML::Xercesc::DefaultHandler_warning;
+*resetErrors = *XML::Xercesc::DefaultHandler_resetErrors;
+*unparsedEntityDecl = *XML::Xercesc::DefaultHandler_unparsedEntityDecl;
+*comment = *XML::Xercesc::DefaultHandler_comment;
+*endCDATA = *XML::Xercesc::DefaultHandler_endCDATA;
+*endDTD = *XML::Xercesc::DefaultHandler_endDTD;
+*endEntity = *XML::Xercesc::DefaultHandler_endEntity;
+*startCDATA = *XML::Xercesc::DefaultHandler_startCDATA;
+*startDTD = *XML::Xercesc::DefaultHandler_startDTD;
+*startEntity = *XML::Xercesc::DefaultHandler_startEntity;
+*attributeDecl = *XML::Xercesc::DefaultHandler_attributeDecl;
+*internalEntityDecl = *XML::Xercesc::DefaultHandler_internalEntityDecl;
+*externalEntityDecl = *XML::Xercesc::DefaultHandler_externalEntityDecl;
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_DefaultHandler(@_);
+ bless $self, $pkg if defined($self);
+}
+
sub DESTROY {
return unless $_[0]->isa('HASH');
my $self = tied(%{$_[0]});
return unless defined $self;
delete $ITERATORS{$self};
if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMProcessingInstruction($self);
- delete $OWNER{$self};
- }
-}
-
-*getTarget = *XML::Xercesc::DOMProcessingInstruction_getTarget;
-*getData = *XML::Xercesc::DOMProcessingInstruction_getData;
-*setData = *XML::Xercesc::DOMProcessingInstruction_setData;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMTypeInfo ##############
-
-package XML::Xerces::DOMTypeInfo;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMTypeInfo($self);
- delete $OWNER{$self};
- }
-}
-
-*DERIVATION_RESTRICTION = *XML::Xercesc::DOMTypeInfo_DERIVATION_RESTRICTION;
-*DERIVATION_EXTENSION = *XML::Xercesc::DOMTypeInfo_DERIVATION_EXTENSION;
-*DERIVATION_UNION = *XML::Xercesc::DOMTypeInfo_DERIVATION_UNION;
-*DERIVATION_LIST = *XML::Xercesc::DOMTypeInfo_DERIVATION_LIST;
-*getTypeName = *XML::Xercesc::DOMTypeInfo_getTypeName;
-*getTypeNamespace = *XML::Xercesc::DOMTypeInfo_getTypeNamespace;
-*isDerivedFrom = *XML::Xercesc::DOMTypeInfo_isDerivedFrom;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMPSVITypeInfo ##############
-
-package XML::Xerces::DOMPSVITypeInfo;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-*PSVI_Validity = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Validity;
-*PSVI_Validitation_Attempted = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Validitation_Attempted;
-*PSVI_Type_Definition_Type = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Type_Definition_Type;
-*PSVI_Type_Definition_Name = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Type_Definition_Name;
-*PSVI_Type_Definition_Namespace = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Type_Definition_Namespace;
-*PSVI_Type_Definition_Anonymous = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Type_Definition_Anonymous;
-*PSVI_Nil = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Nil;
-*PSVI_Member_Type_Definition_Name = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Member_Type_Definition_Name;
-*PSVI_Member_Type_Definition_Namespace = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Member_Type_Definition_Namespace;
-*PSVI_Member_Type_Definition_Anonymous = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Member_Type_Definition_Anonymous;
-*PSVI_Schema_Default = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Schema_Default;
-*PSVI_Schema_Normalized_Value = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Schema_Normalized_Value;
-*PSVI_Schema_Specified = *XML::Xercesc::DOMPSVITypeInfo_PSVI_Schema_Specified;
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMPSVITypeInfo($self);
- delete $OWNER{$self};
- }
-}
-
-*getStringProperty = *XML::Xercesc::DOMPSVITypeInfo_getStringProperty;
-*getNumericProperty = *XML::Xercesc::DOMPSVITypeInfo_getNumericProperty;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMXPathEvaluator ##############
-
-package XML::Xerces::DOMXPathEvaluator;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMXPathEvaluator($self);
- delete $OWNER{$self};
- }
-}
-
-*createExpression = *XML::Xercesc::DOMXPathEvaluator_createExpression;
-*createNSResolver = *XML::Xercesc::DOMXPathEvaluator_createNSResolver;
-*evaluate = *XML::Xercesc::DOMXPathEvaluator_evaluate;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMXPathException ##############
-
-package XML::Xerces::DOMXPathException;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_DOMXPathException(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMXPathException($self);
- delete $OWNER{$self};
- }
-}
-
-*INVALID_EXPRESSION_ERR = *XML::Xercesc::DOMXPathException_INVALID_EXPRESSION_ERR;
-*TYPE_ERR = *XML::Xercesc::DOMXPathException_TYPE_ERR;
-*swig_code_get = *XML::Xercesc::DOMXPathException_code_get;
-*swig_code_set = *XML::Xercesc::DOMXPathException_code_set;
-*swig_msg_get = *XML::Xercesc::DOMXPathException_msg_get;
-*swig_msg_set = *XML::Xercesc::DOMXPathException_msg_set;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMXPathExpression ##############
-
-package XML::Xerces::DOMXPathExpression;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMXPathExpression($self);
- delete $OWNER{$self};
- }
-}
-
-*evaluate = *XML::Xercesc::DOMXPathExpression_evaluate;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMXPathNamespace ##############
-
-package XML::Xerces::DOMXPathNamespace;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNode XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-*XPATH_NAMESPACE_NODE = *XML::Xercesc::DOMXPathNamespace_XPATH_NAMESPACE_NODE;
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMXPathNamespace($self);
- delete $OWNER{$self};
- }
-}
-
-*getOwnerElement = *XML::Xercesc::DOMXPathNamespace_getOwnerElement;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMXPathNSResolver ##############
-
-package XML::Xerces::DOMXPathNSResolver;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMXPathNSResolver($self);
- delete $OWNER{$self};
- }
-}
-
-*lookupNamespaceURI = *XML::Xercesc::DOMXPathNSResolver_lookupNamespaceURI;
-*lookupPrefix = *XML::Xercesc::DOMXPathNSResolver_lookupPrefix;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMXPathResult ##############
-
-package XML::Xerces::DOMXPathResult;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMXPathResult($self);
- delete $OWNER{$self};
- }
-}
-
-*ANY_TYPE = *XML::Xercesc::DOMXPathResult_ANY_TYPE;
-*NUMBER_TYPE = *XML::Xercesc::DOMXPathResult_NUMBER_TYPE;
-*STRING_TYPE = *XML::Xercesc::DOMXPathResult_STRING_TYPE;
-*BOOLEAN_TYPE = *XML::Xercesc::DOMXPathResult_BOOLEAN_TYPE;
-*UNORDERED_NODE_ITERATOR_TYPE = *XML::Xercesc::DOMXPathResult_UNORDERED_NODE_ITERATOR_TYPE;
-*ORDERED_NODE_ITERATOR_TYPE = *XML::Xercesc::DOMXPathResult_ORDERED_NODE_ITERATOR_TYPE;
-*UNORDERED_NODE_SNAPSHOT_TYPE = *XML::Xercesc::DOMXPathResult_UNORDERED_NODE_SNAPSHOT_TYPE;
-*ORDERED_NODE_SNAPSHOT_TYPE = *XML::Xercesc::DOMXPathResult_ORDERED_NODE_SNAPSHOT_TYPE;
-*ANY_UNORDERED_NODE_TYPE = *XML::Xercesc::DOMXPathResult_ANY_UNORDERED_NODE_TYPE;
-*FIRST_ORDERED_NODE_TYPE = *XML::Xercesc::DOMXPathResult_FIRST_ORDERED_NODE_TYPE;
-*getBooleanValue = *XML::Xercesc::DOMXPathResult_getBooleanValue;
-*getInvalidIteratorState = *XML::Xercesc::DOMXPathResult_getInvalidIteratorState;
-*getNumberValue = *XML::Xercesc::DOMXPathResult_getNumberValue;
-*getResultType = *XML::Xercesc::DOMXPathResult_getResultType;
-*getSingleNodeValue = *XML::Xercesc::DOMXPathResult_getSingleNodeValue;
-*getSnapshotLength = *XML::Xercesc::DOMXPathResult_getSnapshotLength;
-*getStringValue = *XML::Xercesc::DOMXPathResult_getStringValue;
-*iterateNext = *XML::Xercesc::DOMXPathResult_iterateNext;
-*snapshotItem = *XML::Xercesc::DOMXPathResult_snapshotItem;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMDocumentRange ##############
-
-package XML::Xerces::DOMDocumentRange;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMDocumentRange($self);
- delete $OWNER{$self};
- }
-}
-
-*createRange = *XML::Xercesc::DOMDocumentRange_createRange;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMDocumentTraversal ##############
-
-package XML::Xerces::DOMDocumentTraversal;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMDocumentTraversal($self);
- delete $OWNER{$self};
- }
-}
-
-sub createNodeIterator {
- my ($self,$root,$what,$filter,$expand) = @_;
- my $callback = XML::Xerces::PerlNodeFilterCallbackHandler->new($filter);
- $XML::Xerces::REMEMBER{tied(% {$self})}->{__NODE_FILTER} = $callback;
-
- my @args = ($self,$root,$what,$callback,$expand);
- if ($args[0]->isa('XML::Xerces::DOMDocument')) {
-
- }
- return XML::Xercesc::DOMDocumentTraversal_createNodeIterator(@args);
-}
-
-sub createTreeWalker {
- my ($self,$root,$what,$filter,$expand) = @_;
- my $callback = XML::Xerces::PerlNodeFilterCallbackHandler->new($filter);
- $XML::Xerces::REMEMBER{tied(% {$self})}->{__NODE_FILTER} = $callback;
-
- my @args = ($self,$root,$what,$callback,$expand);
- if ($args[0]->isa('XML::Xerces::DOMDocument')) {
-
- }
- return XML::Xercesc::DOMDocumentTraversal_createTreeWalker(@args);
-}
-
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMNodeIterator ##############
-
-package XML::Xerces::DOMNodeIterator;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMNodeIterator($self);
- delete $OWNER{$self};
- }
-}
-
-*getRoot = *XML::Xercesc::DOMNodeIterator_getRoot;
-*getWhatToShow = *XML::Xercesc::DOMNodeIterator_getWhatToShow;
-*getFilter = *XML::Xercesc::DOMNodeIterator_getFilter;
-*getExpandEntityReferences = *XML::Xercesc::DOMNodeIterator_getExpandEntityReferences;
-*nextNode = *XML::Xercesc::DOMNodeIterator_nextNode;
-*previousNode = *XML::Xercesc::DOMNodeIterator_previousNode;
-*detach = *XML::Xercesc::DOMNodeIterator_detach;
-*release = *XML::Xercesc::DOMNodeIterator_release;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMNodeFilter ##############
-
-package XML::Xerces::DOMNodeFilter;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMNodeFilter($self);
- delete $OWNER{$self};
- }
-}
-
-*FILTER_ACCEPT = *XML::Xercesc::DOMNodeFilter_FILTER_ACCEPT;
-*FILTER_REJECT = *XML::Xercesc::DOMNodeFilter_FILTER_REJECT;
-*FILTER_SKIP = *XML::Xercesc::DOMNodeFilter_FILTER_SKIP;
-*SHOW_ALL = *XML::Xercesc::DOMNodeFilter_SHOW_ALL;
-*SHOW_ELEMENT = *XML::Xercesc::DOMNodeFilter_SHOW_ELEMENT;
-*SHOW_ATTRIBUTE = *XML::Xercesc::DOMNodeFilter_SHOW_ATTRIBUTE;
-*SHOW_TEXT = *XML::Xercesc::DOMNodeFilter_SHOW_TEXT;
-*SHOW_CDATA_SECTION = *XML::Xercesc::DOMNodeFilter_SHOW_CDATA_SECTION;
-*SHOW_ENTITY_REFERENCE = *XML::Xercesc::DOMNodeFilter_SHOW_ENTITY_REFERENCE;
-*SHOW_ENTITY = *XML::Xercesc::DOMNodeFilter_SHOW_ENTITY;
-*SHOW_PROCESSING_INSTRUCTION = *XML::Xercesc::DOMNodeFilter_SHOW_PROCESSING_INSTRUCTION;
-*SHOW_COMMENT = *XML::Xercesc::DOMNodeFilter_SHOW_COMMENT;
-*SHOW_DOCUMENT = *XML::Xercesc::DOMNodeFilter_SHOW_DOCUMENT;
-*SHOW_DOCUMENT_TYPE = *XML::Xercesc::DOMNodeFilter_SHOW_DOCUMENT_TYPE;
-*SHOW_DOCUMENT_FRAGMENT = *XML::Xercesc::DOMNodeFilter_SHOW_DOCUMENT_FRAGMENT;
-*SHOW_NOTATION = *XML::Xercesc::DOMNodeFilter_SHOW_NOTATION;
-*acceptNode = *XML::Xercesc::DOMNodeFilter_acceptNode;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMRange ##############
-
-package XML::Xerces::DOMRange;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMRange($self);
- delete $OWNER{$self};
- }
-}
-
-*START_TO_START = *XML::Xercesc::DOMRange_START_TO_START;
-*START_TO_END = *XML::Xercesc::DOMRange_START_TO_END;
-*END_TO_END = *XML::Xercesc::DOMRange_END_TO_END;
-*END_TO_START = *XML::Xercesc::DOMRange_END_TO_START;
-*getStartContainer = *XML::Xercesc::DOMRange_getStartContainer;
-*getStartOffset = *XML::Xercesc::DOMRange_getStartOffset;
-*getEndContainer = *XML::Xercesc::DOMRange_getEndContainer;
-*getEndOffset = *XML::Xercesc::DOMRange_getEndOffset;
-*getCollapsed = *XML::Xercesc::DOMRange_getCollapsed;
-*getCommonAncestorContainer = *XML::Xercesc::DOMRange_getCommonAncestorContainer;
-*setStart = *XML::Xercesc::DOMRange_setStart;
-*setEnd = *XML::Xercesc::DOMRange_setEnd;
-*setStartBefore = *XML::Xercesc::DOMRange_setStartBefore;
-*setStartAfter = *XML::Xercesc::DOMRange_setStartAfter;
-*setEndBefore = *XML::Xercesc::DOMRange_setEndBefore;
-*setEndAfter = *XML::Xercesc::DOMRange_setEndAfter;
-*collapse = *XML::Xercesc::DOMRange_collapse;
-*selectNode = *XML::Xercesc::DOMRange_selectNode;
-*selectNodeContents = *XML::Xercesc::DOMRange_selectNodeContents;
-*compareBoundaryPoints = *XML::Xercesc::DOMRange_compareBoundaryPoints;
-*deleteContents = *XML::Xercesc::DOMRange_deleteContents;
-*extractContents = *XML::Xercesc::DOMRange_extractContents;
-*cloneContents = *XML::Xercesc::DOMRange_cloneContents;
-*insertNode = *XML::Xercesc::DOMRange_insertNode;
-*surroundContents = *XML::Xercesc::DOMRange_surroundContents;
-*cloneRange = *XML::Xercesc::DOMRange_cloneRange;
-*toString = *XML::Xercesc::DOMRange_toString;
-*detach = *XML::Xercesc::DOMRange_detach;
-*release = *XML::Xercesc::DOMRange_release;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMRangeException ##############
-
-package XML::Xerces::DOMRangeException;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMException XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-*BAD_BOUNDARYPOINTS_ERR = *XML::Xercesc::DOMRangeException_BAD_BOUNDARYPOINTS_ERR;
-*INVALID_NODE_TYPE_ERR = *XML::Xercesc::DOMRangeException_INVALID_NODE_TYPE_ERR;
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_DOMRangeException(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMRangeException($self);
- delete $OWNER{$self};
- }
-}
-
-*swig_code_get = *XML::Xercesc::DOMRangeException_code_get;
-*swig_code_set = *XML::Xercesc::DOMRangeException_code_set;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMTreeWalker ##############
-
-package XML::Xerces::DOMTreeWalker;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMTreeWalker($self);
- delete $OWNER{$self};
- }
-}
-
-*getRoot = *XML::Xercesc::DOMTreeWalker_getRoot;
-*getWhatToShow = *XML::Xercesc::DOMTreeWalker_getWhatToShow;
-*getFilter = *XML::Xercesc::DOMTreeWalker_getFilter;
-*getExpandEntityReferences = *XML::Xercesc::DOMTreeWalker_getExpandEntityReferences;
-*getCurrentNode = *XML::Xercesc::DOMTreeWalker_getCurrentNode;
-*parentNode = *XML::Xercesc::DOMTreeWalker_parentNode;
-*firstChild = *XML::Xercesc::DOMTreeWalker_firstChild;
-*lastChild = *XML::Xercesc::DOMTreeWalker_lastChild;
-*previousSibling = *XML::Xercesc::DOMTreeWalker_previousSibling;
-*nextSibling = *XML::Xercesc::DOMTreeWalker_nextSibling;
-*previousNode = *XML::Xercesc::DOMTreeWalker_previousNode;
-*nextNode = *XML::Xercesc::DOMTreeWalker_nextNode;
-*setCurrentNode = *XML::Xercesc::DOMTreeWalker_setCurrentNode;
-*release = *XML::Xercesc::DOMTreeWalker_release;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMUserDataHandler ##############
-
-package XML::Xerces::DOMUserDataHandler;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMUserDataHandler($self);
- delete $OWNER{$self};
- }
-}
-
-*NODE_CLONED = *XML::Xercesc::DOMUserDataHandler_NODE_CLONED;
-*NODE_IMPORTED = *XML::Xercesc::DOMUserDataHandler_NODE_IMPORTED;
-*NODE_DELETED = *XML::Xercesc::DOMUserDataHandler_NODE_DELETED;
-*NODE_RENAMED = *XML::Xercesc::DOMUserDataHandler_NODE_RENAMED;
-*NODE_ADOPTED = *XML::Xercesc::DOMUserDataHandler_NODE_ADOPTED;
-*handle = *XML::Xercesc::DOMUserDataHandler_handle;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMConfiguration ##############
-
-package XML::Xerces::DOMConfiguration;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub setParameter {
- my ($self,$name,$value) = @_;
-
- if ($name eq $XML::Xerces::XMLUni::fgDOMErrorHandler) {
- $value = XML::Xerces::PerlErrorCallbackHandler->new($_[2]);
- $XML::Xerces::REMEMBER{tied(% {$self})}->{__ERROR_HANDLER} = $value;
- } elsif ($name eq $XML::Xerces::XMLUni::fgXercesEntityResolver) {
- $value = XML::Xerces::PerlEntityResolverHandler->new($_[2]);
- $XML::Xerces::REMEMBER{tied(% {$self})}->{__ENTITY_RESOLVER} = $value;
- }
- return XML::Xercesc::DOMConfiguration_setParameter($self,$name,$value);
-}
-
-*getParameter = *XML::Xercesc::DOMConfiguration_getParameter;
-*canSetParameter = *XML::Xercesc::DOMConfiguration_canSetParameter;
-*getParameterNames = *XML::Xercesc::DOMConfiguration_getParameterNames;
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMConfiguration($self);
- delete $OWNER{$self};
- }
-}
-
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMStringList ##############
-
-package XML::Xerces::DOMStringList;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMStringList($self);
- delete $OWNER{$self};
- }
-}
-
-*item = *XML::Xercesc::DOMStringList_item;
-*getLength = *XML::Xercesc::DOMStringList_getLength;
-*contains = *XML::Xercesc::DOMStringList_contains;
-*release = *XML::Xercesc::DOMStringList_release;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMImplementationLS ##############
-
-package XML::Xerces::DOMImplementationLS;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMImplementationLS($self);
- delete $OWNER{$self};
- }
-}
-
-*MODE_SYNCHRONOUS = *XML::Xercesc::DOMImplementationLS_MODE_SYNCHRONOUS;
-*MODE_ASYNCHRONOUS = *XML::Xercesc::DOMImplementationLS_MODE_ASYNCHRONOUS;
-*createLSParser = *XML::Xercesc::DOMImplementationLS_createLSParser;
-*createLSSerializer = *XML::Xercesc::DOMImplementationLS_createLSSerializer;
-*createLSInput = *XML::Xercesc::DOMImplementationLS_createLSInput;
-*createLSOutput = *XML::Xercesc::DOMImplementationLS_createLSOutput;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMImplementation ##############
-
-package XML::Xerces::DOMImplementation;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMImplementationLS XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMImplementation($self);
- delete $OWNER{$self};
- }
-}
-
-*hasFeature = *XML::Xercesc::DOMImplementation_hasFeature;
-*createDocumentType = *XML::Xercesc::DOMImplementation_createDocumentType;
-*getFeature = *XML::Xercesc::DOMImplementation_getFeature;
-sub createDocument {
- if (UNIVERSAL::isa($_[3],"XML::Xerces::DOMDocumentType")) {
- $_[3]->DISOWN();
- }
-
- my $return = XML::Xercesc::DOMImplementation_createDocument(@_);
-
- return $return;
-}
-
-*getImplementation = *XML::Xercesc::DOMImplementation_getImplementation;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMImplementationList ##############
-
-package XML::Xerces::DOMImplementationList;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMImplementationList($self);
- delete $OWNER{$self};
- }
-}
-
-*item = *XML::Xercesc::DOMImplementationList_item;
-*getLength = *XML::Xercesc::DOMImplementationList_getLength;
-*release = *XML::Xercesc::DOMImplementationList_release;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMImplementationSource ##############
-
-package XML::Xerces::DOMImplementationSource;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMImplementationSource($self);
- delete $OWNER{$self};
- }
-}
-
-*getDOMImplementation = *XML::Xercesc::DOMImplementationSource_getDOMImplementation;
-*getDOMImplementationList = *XML::Xercesc::DOMImplementationSource_getDOMImplementationList;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMImplementationRegistry ##############
-
-package XML::Xerces::DOMImplementationRegistry;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-*getDOMImplementation = *XML::Xercesc::DOMImplementationRegistry_getDOMImplementation;
-*getDOMImplementationList = *XML::Xercesc::DOMImplementationRegistry_getDOMImplementationList;
-*addSource = *XML::Xercesc::DOMImplementationRegistry_addSource;
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMImplementationRegistry($self);
- delete $OWNER{$self};
- }
-}
-
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMError ##############
-
-package XML::Xerces::DOMError;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMError($self);
- delete $OWNER{$self};
- }
-}
-
-*DOM_SEVERITY_WARNING = *XML::Xercesc::DOMError_DOM_SEVERITY_WARNING;
-*DOM_SEVERITY_ERROR = *XML::Xercesc::DOMError_DOM_SEVERITY_ERROR;
-*DOM_SEVERITY_FATAL_ERROR = *XML::Xercesc::DOMError_DOM_SEVERITY_FATAL_ERROR;
-*getSeverity = *XML::Xercesc::DOMError_getSeverity;
-*getMessage = *XML::Xercesc::DOMError_getMessage;
-*getLocation = *XML::Xercesc::DOMError_getLocation;
-*getRelatedException = *XML::Xercesc::DOMError_getRelatedException;
-*getType = *XML::Xercesc::DOMError_getType;
-*getRelatedData = *XML::Xercesc::DOMError_getRelatedData;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMErrorHandler ##############
-
-package XML::Xerces::DOMErrorHandler;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMErrorHandler($self);
- delete $OWNER{$self};
- }
-}
-
-*handleError = *XML::Xercesc::DOMErrorHandler_handleError;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMDocument ##############
-
-package XML::Xerces::DOMDocument;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMDocumentRange XML::Xerces::DOMXPathEvaluator XML::Xerces::DOMDocumentTraversal XML::Xerces::DOMNode XML::Xerces );
-%OWNER = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
-
- if ($self->can('cleanup')) {
- $_[0]->cleanup();
- }
-
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMDocument($self);
- delete $OWNER{$self};
- }
-}
-
-*createElement = *XML::Xercesc::DOMDocument_createElement;
-*createDocumentFragment = *XML::Xercesc::DOMDocument_createDocumentFragment;
-*createTextNode = *XML::Xercesc::DOMDocument_createTextNode;
-*createComment = *XML::Xercesc::DOMDocument_createComment;
-*createCDATASection = *XML::Xercesc::DOMDocument_createCDATASection;
-*createProcessingInstruction = *XML::Xercesc::DOMDocument_createProcessingInstruction;
-*createAttribute = *XML::Xercesc::DOMDocument_createAttribute;
-*createEntityReference = *XML::Xercesc::DOMDocument_createEntityReference;
-*getDoctype = *XML::Xercesc::DOMDocument_getDoctype;
-*getImplementation = *XML::Xercesc::DOMDocument_getImplementation;
-*getDocumentElement = *XML::Xercesc::DOMDocument_getDocumentElement;
-sub getElementsByTagName {
- my $result = XML::Xercesc::DOMDocument_getElementsByTagName (@_);
- unless (defined$result) {
- return () if wantarray;
- return undef;#if *not* wantarray
- }
- return $result->to_list() if wantarray;
- return $result;#if *not* wantarray
-}
-
-*importNode = *XML::Xercesc::DOMDocument_importNode;
-*createAttributeNS = *XML::Xercesc::DOMDocument_createAttributeNS;
-sub getElementsByTagNameNS {
- my $result = XML::Xercesc::DOMDocument_getElementsByTagNameNS (@_);
- unless (defined$result) {
- return () if wantarray;
- return undef;#if *not* wantarray
- }
- return $result->to_list() if wantarray;
- return $result;#if *not* wantarray
-}
-
-*getElementById = *XML::Xercesc::DOMDocument_getElementById;
-*getInputEncoding = *XML::Xercesc::DOMDocument_getInputEncoding;
-*getXmlEncoding = *XML::Xercesc::DOMDocument_getXmlEncoding;
-*getXmlStandalone = *XML::Xercesc::DOMDocument_getXmlStandalone;
-*setXmlStandalone = *XML::Xercesc::DOMDocument_setXmlStandalone;
-*getXmlVersion = *XML::Xercesc::DOMDocument_getXmlVersion;
-*setXmlVersion = *XML::Xercesc::DOMDocument_setXmlVersion;
-*getDocumentURI = *XML::Xercesc::DOMDocument_getDocumentURI;
-*setDocumentURI = *XML::Xercesc::DOMDocument_setDocumentURI;
-*getStrictErrorChecking = *XML::Xercesc::DOMDocument_getStrictErrorChecking;
-*setStrictErrorChecking = *XML::Xercesc::DOMDocument_setStrictErrorChecking;
-*renameNode = *XML::Xercesc::DOMDocument_renameNode;
-*adoptNode = *XML::Xercesc::DOMDocument_adoptNode;
-*normalizeDocument = *XML::Xercesc::DOMDocument_normalizeDocument;
-*getDOMConfig = *XML::Xercesc::DOMDocument_getDOMConfig;
-*createEntity = *XML::Xercesc::DOMDocument_createEntity;
-*createDocumentType = *XML::Xercesc::DOMDocument_createDocumentType;
-*createNotation = *XML::Xercesc::DOMDocument_createNotation;
-*createElementNS = *XML::Xercesc::DOMDocument_createElementNS;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMLocator ##############
-
-package XML::Xerces::DOMLocator;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMLocator($self);
- delete $OWNER{$self};
- }
-}
-
-*getLineNumber = *XML::Xercesc::DOMLocator_getLineNumber;
-*getColumnNumber = *XML::Xercesc::DOMLocator_getColumnNumber;
-*getByteOffset = *XML::Xercesc::DOMLocator_getByteOffset;
-*getUtf16Offset = *XML::Xercesc::DOMLocator_getUtf16Offset;
-*getRelatedNode = *XML::Xercesc::DOMLocator_getRelatedNode;
-*getURI = *XML::Xercesc::DOMLocator_getURI;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMLSResourceResolver ##############
-
-package XML::Xerces::DOMLSResourceResolver;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMLSResourceResolver($self);
- delete $OWNER{$self};
- }
-}
-
-*resolveResource = *XML::Xercesc::DOMLSResourceResolver_resolveResource;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMLSInput ##############
-
-package XML::Xerces::DOMLSInput;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMLSInput($self);
- delete $OWNER{$self};
- }
-}
-
-*getStringData = *XML::Xercesc::DOMLSInput_getStringData;
-*getByteStream = *XML::Xercesc::DOMLSInput_getByteStream;
-*getEncoding = *XML::Xercesc::DOMLSInput_getEncoding;
-*getPublicId = *XML::Xercesc::DOMLSInput_getPublicId;
-*getSystemId = *XML::Xercesc::DOMLSInput_getSystemId;
-*getBaseURI = *XML::Xercesc::DOMLSInput_getBaseURI;
-*setStringData = *XML::Xercesc::DOMLSInput_setStringData;
-*setByteStream = *XML::Xercesc::DOMLSInput_setByteStream;
-*setEncoding = *XML::Xercesc::DOMLSInput_setEncoding;
-*setPublicId = *XML::Xercesc::DOMLSInput_setPublicId;
-*setSystemId = *XML::Xercesc::DOMLSInput_setSystemId;
-*setBaseURI = *XML::Xercesc::DOMLSInput_setBaseURI;
-*setIssueFatalErrorIfNotFound = *XML::Xercesc::DOMLSInput_setIssueFatalErrorIfNotFound;
-*getIssueFatalErrorIfNotFound = *XML::Xercesc::DOMLSInput_getIssueFatalErrorIfNotFound;
-*release = *XML::Xercesc::DOMLSInput_release;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::Wrapper4InputSource ##############
-
-package XML::Xerces::Wrapper4InputSource;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMLSInput XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub new {
- my $pkg = shift;
- # we never handle the memory
- # so we tell Perl to forget about the InputSource
- $_[0]->DISOWN();
-
- my $self = XML::Xercesc::new_Wrapper4InputSource(@_);
-
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_Wrapper4InputSource($self);
- delete $OWNER{$self};
- }
-}
-
-*getStringData = *XML::Xercesc::Wrapper4InputSource_getStringData;
-*getByteStream = *XML::Xercesc::Wrapper4InputSource_getByteStream;
-*getEncoding = *XML::Xercesc::Wrapper4InputSource_getEncoding;
-*getPublicId = *XML::Xercesc::Wrapper4InputSource_getPublicId;
-*getSystemId = *XML::Xercesc::Wrapper4InputSource_getSystemId;
-*getBaseURI = *XML::Xercesc::Wrapper4InputSource_getBaseURI;
-*getIssueFatalErrorIfNotFound = *XML::Xercesc::Wrapper4InputSource_getIssueFatalErrorIfNotFound;
-*setStringData = *XML::Xercesc::Wrapper4InputSource_setStringData;
-*setByteStream = *XML::Xercesc::Wrapper4InputSource_setByteStream;
-*setEncoding = *XML::Xercesc::Wrapper4InputSource_setEncoding;
-*setPublicId = *XML::Xercesc::Wrapper4InputSource_setPublicId;
-*setSystemId = *XML::Xercesc::Wrapper4InputSource_setSystemId;
-*setBaseURI = *XML::Xercesc::Wrapper4InputSource_setBaseURI;
-*setIssueFatalErrorIfNotFound = *XML::Xercesc::Wrapper4InputSource_setIssueFatalErrorIfNotFound;
-*release = *XML::Xercesc::Wrapper4InputSource_release;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::Wrapper4DOMLSInput ##############
-
-package XML::Xerces::Wrapper4DOMLSInput;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::InputSource XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_Wrapper4DOMLSInput(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_Wrapper4DOMLSInput($self);
- delete $OWNER{$self};
- }
-}
-
-*makeStream = *XML::Xercesc::Wrapper4DOMLSInput_makeStream;
-*getEncoding = *XML::Xercesc::Wrapper4DOMLSInput_getEncoding;
-*getPublicId = *XML::Xercesc::Wrapper4DOMLSInput_getPublicId;
-*getSystemId = *XML::Xercesc::Wrapper4DOMLSInput_getSystemId;
-*getIssueFatalErrorIfNotFound = *XML::Xercesc::Wrapper4DOMLSInput_getIssueFatalErrorIfNotFound;
-*setEncoding = *XML::Xercesc::Wrapper4DOMLSInput_setEncoding;
-*setPublicId = *XML::Xercesc::Wrapper4DOMLSInput_setPublicId;
-*setSystemId = *XML::Xercesc::Wrapper4DOMLSInput_setSystemId;
-*setIssueFatalErrorIfNotFound = *XML::Xercesc::Wrapper4DOMLSInput_setIssueFatalErrorIfNotFound;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMLSParser ##############
-
-package XML::Xerces::DOMLSParser;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMLSParser($self);
- delete $OWNER{$self};
- }
-}
-
-*ACTION_APPEND_AS_CHILDREN = *XML::Xercesc::DOMLSParser_ACTION_APPEND_AS_CHILDREN;
-*ACTION_REPLACE_CHILDREN = *XML::Xercesc::DOMLSParser_ACTION_REPLACE_CHILDREN;
-*ACTION_INSERT_BEFORE = *XML::Xercesc::DOMLSParser_ACTION_INSERT_BEFORE;
-*ACTION_INSERT_AFTER = *XML::Xercesc::DOMLSParser_ACTION_INSERT_AFTER;
-*ACTION_REPLACE = *XML::Xercesc::DOMLSParser_ACTION_REPLACE;
-*getDomConfig = *XML::Xercesc::DOMLSParser_getDomConfig;
-*getAsync = *XML::Xercesc::DOMLSParser_getAsync;
-*getBusy = *XML::Xercesc::DOMLSParser_getBusy;
-*setFilter = *XML::Xercesc::DOMLSParser_setFilter;
-*parse = *XML::Xercesc::DOMLSParser_parse;
-*parseURI = *XML::Xercesc::DOMLSParser_parseURI;
-*parseWithContext = *XML::Xercesc::DOMLSParser_parseWithContext;
-*abort = *XML::Xercesc::DOMLSParser_abort;
-*release = *XML::Xercesc::DOMLSParser_release;
-*resetDocumentPool = *XML::Xercesc::DOMLSParser_resetDocumentPool;
-*loadGrammar = *XML::Xercesc::DOMLSParser_loadGrammar;
-*getGrammar = *XML::Xercesc::DOMLSParser_getGrammar;
-*getRootGrammar = *XML::Xercesc::DOMLSParser_getRootGrammar;
-*getURIText = *XML::Xercesc::DOMLSParser_getURIText;
-*resetCachedGrammarPool = *XML::Xercesc::DOMLSParser_resetCachedGrammarPool;
-*getSrcOffset = *XML::Xercesc::DOMLSParser_getSrcOffset;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMLSOutput ##############
-
-package XML::Xerces::DOMLSOutput;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMLSOutput($self);
- delete $OWNER{$self};
- }
-}
-
-*getByteStream = *XML::Xercesc::DOMLSOutput_getByteStream;
-*getEncoding = *XML::Xercesc::DOMLSOutput_getEncoding;
-*getSystemId = *XML::Xercesc::DOMLSOutput_getSystemId;
-*setByteStream = *XML::Xercesc::DOMLSOutput_setByteStream;
-*setEncoding = *XML::Xercesc::DOMLSOutput_setEncoding;
-*setSystemId = *XML::Xercesc::DOMLSOutput_setSystemId;
-*release = *XML::Xercesc::DOMLSOutput_release;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::StdOutFormatTarget ##############
-
-package XML::Xerces::StdOutFormatTarget;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_StdOutFormatTarget(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_StdOutFormatTarget($self);
- delete $OWNER{$self};
- }
-}
-
-*writeChars = *XML::Xercesc::StdOutFormatTarget_writeChars;
-*flush = *XML::Xercesc::StdOutFormatTarget_flush;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::LocalFileFormatTarget ##############
-
-package XML::Xerces::LocalFileFormatTarget;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_LocalFileFormatTarget(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_LocalFileFormatTarget($self);
- delete $OWNER{$self};
- }
-}
-
-*writeChars = *XML::Xercesc::LocalFileFormatTarget_writeChars;
-*flush = *XML::Xercesc::LocalFileFormatTarget_flush;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::MemBufFormatTarget ##############
-
-package XML::Xerces::MemBufFormatTarget;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_MemBufFormatTarget(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_MemBufFormatTarget($self);
- delete $OWNER{$self};
- }
-}
-
-*writeChars = *XML::Xercesc::MemBufFormatTarget_writeChars;
-*getRawBuffer = *XML::Xercesc::MemBufFormatTarget_getRawBuffer;
-*getLen = *XML::Xercesc::MemBufFormatTarget_getLen;
-*reset = *XML::Xercesc::MemBufFormatTarget_reset;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMLSException ##############
-
-package XML::Xerces::DOMLSException;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMException XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-*PARSE_ERR = *XML::Xercesc::DOMLSException_PARSE_ERR;
-*SERIALIZE_ERR = *XML::Xercesc::DOMLSException_SERIALIZE_ERR;
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_DOMLSException(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMLSException($self);
- delete $OWNER{$self};
- }
-}
-
-*getMessage = *XML::Xercesc::DOMLSException_getMessage;
-*swig_code_get = *XML::Xercesc::DOMLSException_code_get;
-*swig_code_set = *XML::Xercesc::DOMLSException_code_set;
-*swig_msg_get = *XML::Xercesc::DOMLSException_msg_get;
-*swig_msg_set = *XML::Xercesc::DOMLSException_msg_set;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMLSSerializer ##############
-
-package XML::Xerces::DOMLSSerializer;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMLSSerializer($self);
- delete $OWNER{$self};
- }
-}
-
-*getDomConfig = *XML::Xercesc::DOMLSSerializer_getDomConfig;
-*setNewLine = *XML::Xercesc::DOMLSSerializer_setNewLine;
-*setFilter = *XML::Xercesc::DOMLSSerializer_setFilter;
-*getNewLine = *XML::Xercesc::DOMLSSerializer_getNewLine;
-*write = *XML::Xercesc::DOMLSSerializer_write;
-*writeToURI = *XML::Xercesc::DOMLSSerializer_writeToURI;
-*writeToString = *XML::Xercesc::DOMLSSerializer_writeToString;
-*release = *XML::Xercesc::DOMLSSerializer_release;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DOMLSSerializerFilter ##############
-
-package XML::Xerces::DOMLSSerializerFilter;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNodeFilter XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DOMLSSerializerFilter($self);
- delete $OWNER{$self};
- }
-}
-
-*acceptNode = *XML::Xercesc::DOMLSSerializerFilter_acceptNode;
-*getWhatToShow = *XML::Xercesc::DOMLSSerializerFilter_getWhatToShow;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::SAXException ##############
-
-package XML::Xerces::SAXException;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_SAXException($self);
- delete $OWNER{$self};
- }
-}
-
-*getMessage = *XML::Xercesc::SAXException_getMessage;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::SAXNotSupportedException ##############
-
-package XML::Xerces::SAXNotSupportedException;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::SAXException XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_SAXNotSupportedException(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_SAXNotSupportedException($self);
- delete $OWNER{$self};
- }
-}
-
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::SAXNotRecognizedException ##############
-
-package XML::Xerces::SAXNotRecognizedException;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::SAXException XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_SAXNotRecognizedException(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_SAXNotRecognizedException($self);
- delete $OWNER{$self};
- }
-}
-
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::SAXParseException ##############
-
-package XML::Xerces::SAXParseException;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::SAXException XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_SAXParseException($self);
- delete $OWNER{$self};
- }
-}
-
-*getColumnNumber = *XML::Xercesc::SAXParseException_getColumnNumber;
-*getLineNumber = *XML::Xercesc::SAXParseException_getLineNumber;
-*getPublicId = *XML::Xercesc::SAXParseException_getPublicId;
-*getSystemId = *XML::Xercesc::SAXParseException_getSystemId;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::ErrorHandler ##############
-
-package XML::Xerces::ErrorHandler;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_ErrorHandler($self);
- delete $OWNER{$self};
- }
-}
-
-*warning = *XML::Xercesc::ErrorHandler_warning;
-*error = *XML::Xercesc::ErrorHandler_error;
-*fatalError = *XML::Xercesc::ErrorHandler_fatalError;
-*resetErrors = *XML::Xercesc::ErrorHandler_resetErrors;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DTDHandler ##############
-
-package XML::Xerces::DTDHandler;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DTDHandler($self);
- delete $OWNER{$self};
- }
-}
-
-*unparsedEntityDecl = *XML::Xercesc::DTDHandler_unparsedEntityDecl;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DocumentHandler ##############
-
-package XML::Xerces::DocumentHandler;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DocumentHandler($self);
- delete $OWNER{$self};
- }
-}
-
-*characters = *XML::Xercesc::DocumentHandler_characters;
-*processingInstruction = *XML::Xercesc::DocumentHandler_processingInstruction;
-*setDocumentLocator = *XML::Xercesc::DocumentHandler_setDocumentLocator;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::EntityResolver ##############
-
-package XML::Xerces::EntityResolver;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_EntityResolver($self);
- delete $OWNER{$self};
- }
-}
-
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::AttributeList ##############
-
-package XML::Xerces::AttributeList;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_AttributeList($self);
- delete $OWNER{$self};
- }
-}
-
-*getLength = *XML::Xercesc::AttributeList_getLength;
-*getName = *XML::Xercesc::AttributeList_getName;
-*getType = *XML::Xercesc::AttributeList_getType;
-*getValue = *XML::Xercesc::AttributeList_getValue;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::HandlerBase ##############
-
-package XML::Xerces::HandlerBase;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::EntityResolver XML::Xerces::DTDHandler XML::Xerces::DocumentHandler XML::Xerces::ErrorHandler XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-*characters = *XML::Xercesc::HandlerBase_characters;
-*processingInstruction = *XML::Xercesc::HandlerBase_processingInstruction;
-*setDocumentLocator = *XML::Xercesc::HandlerBase_setDocumentLocator;
-*error = *XML::Xercesc::HandlerBase_error;
-*fatalError = *XML::Xercesc::HandlerBase_fatalError;
-*warning = *XML::Xercesc::HandlerBase_warning;
-*resetErrors = *XML::Xercesc::HandlerBase_resetErrors;
-*unparsedEntityDecl = *XML::Xercesc::HandlerBase_unparsedEntityDecl;
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_HandlerBase(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_HandlerBase($self);
- delete $OWNER{$self};
- }
-}
-
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::Locator ##############
-
-package XML::Xerces::Locator;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_Locator($self);
- delete $OWNER{$self};
- }
-}
-
-*getPublicId = *XML::Xercesc::Locator_getPublicId;
-*getSystemId = *XML::Xercesc::Locator_getSystemId;
-*getLineNumber = *XML::Xercesc::Locator_getLineNumber;
-*getColumnNumber = *XML::Xercesc::Locator_getColumnNumber;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::Attributes ##############
-
-package XML::Xerces::Attributes;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_Attributes($self);
- delete $OWNER{$self};
- }
-}
-
-*getLength = *XML::Xercesc::Attributes_getLength;
-*getURI = *XML::Xercesc::Attributes_getURI;
-*getLocalName = *XML::Xercesc::Attributes_getLocalName;
-*getQName = *XML::Xercesc::Attributes_getQName;
-*getIndex = *XML::Xercesc::Attributes_getIndex;
-*getType = *XML::Xercesc::Attributes_getType;
-*getValue = *XML::Xercesc::Attributes_getValue;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::ContentHandler ##############
-
-package XML::Xerces::ContentHandler;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_ContentHandler($self);
- delete $OWNER{$self};
- }
-}
-
-*characters = *XML::Xercesc::ContentHandler_characters;
-*processingInstruction = *XML::Xercesc::ContentHandler_processingInstruction;
-*setDocumentLocator = *XML::Xercesc::ContentHandler_setDocumentLocator;
-*startPrefixMapping = *XML::Xercesc::ContentHandler_startPrefixMapping;
-*endPrefixMapping = *XML::Xercesc::ContentHandler_endPrefixMapping;
-*skippedEntity = *XML::Xercesc::ContentHandler_skippedEntity;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::LexicalHandler ##############
-
-package XML::Xerces::LexicalHandler;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_LexicalHandler($self);
- delete $OWNER{$self};
- }
-}
-
-*comment = *XML::Xercesc::LexicalHandler_comment;
-*endCDATA = *XML::Xercesc::LexicalHandler_endCDATA;
-*endDTD = *XML::Xercesc::LexicalHandler_endDTD;
-*endEntity = *XML::Xercesc::LexicalHandler_endEntity;
-*startCDATA = *XML::Xercesc::LexicalHandler_startCDATA;
-*startDTD = *XML::Xercesc::LexicalHandler_startDTD;
-*startEntity = *XML::Xercesc::LexicalHandler_startEntity;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DeclHandler ##############
-
-package XML::Xerces::DeclHandler;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DeclHandler($self);
- delete $OWNER{$self};
- }
-}
-
-*attributeDecl = *XML::Xercesc::DeclHandler_attributeDecl;
-*internalEntityDecl = *XML::Xercesc::DeclHandler_internalEntityDecl;
-*externalEntityDecl = *XML::Xercesc::DeclHandler_externalEntityDecl;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::DefaultHandler ##############
-
-package XML::Xerces::DefaultHandler;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::EntityResolver XML::Xerces::DTDHandler XML::Xerces::ContentHandler XML::Xerces::ErrorHandler XML::Xerces::LexicalHandler XML::Xerces::DeclHandler XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-*characters = *XML::Xercesc::DefaultHandler_characters;
-*processingInstruction = *XML::Xercesc::DefaultHandler_processingInstruction;
-*setDocumentLocator = *XML::Xercesc::DefaultHandler_setDocumentLocator;
-*startPrefixMapping = *XML::Xercesc::DefaultHandler_startPrefixMapping;
-*endPrefixMapping = *XML::Xercesc::DefaultHandler_endPrefixMapping;
-*skippedEntity = *XML::Xercesc::DefaultHandler_skippedEntity;
-*error = *XML::Xercesc::DefaultHandler_error;
-*fatalError = *XML::Xercesc::DefaultHandler_fatalError;
-*warning = *XML::Xercesc::DefaultHandler_warning;
-*resetErrors = *XML::Xercesc::DefaultHandler_resetErrors;
-*unparsedEntityDecl = *XML::Xercesc::DefaultHandler_unparsedEntityDecl;
-*comment = *XML::Xercesc::DefaultHandler_comment;
-*endCDATA = *XML::Xercesc::DefaultHandler_endCDATA;
-*endDTD = *XML::Xercesc::DefaultHandler_endDTD;
-*endEntity = *XML::Xercesc::DefaultHandler_endEntity;
-*startCDATA = *XML::Xercesc::DefaultHandler_startCDATA;
-*startDTD = *XML::Xercesc::DefaultHandler_startDTD;
-*startEntity = *XML::Xercesc::DefaultHandler_startEntity;
-*attributeDecl = *XML::Xercesc::DefaultHandler_attributeDecl;
-*internalEntityDecl = *XML::Xercesc::DefaultHandler_internalEntityDecl;
-*externalEntityDecl = *XML::Xercesc::DefaultHandler_externalEntityDecl;
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_DefaultHandler(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_DefaultHandler($self);
+ XML::Xercesc::delete_DefaultHandler($self);
delete $OWNER{$self};
}
}
@@ -6394,183 +3854,6 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::AbstractDOMParser ##############
-
-package XML::Xerces::AbstractDOMParser;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::PSVIHandler XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-*Val_Never = *XML::Xercesc::AbstractDOMParser_Val_Never;
-*Val_Always = *XML::Xercesc::AbstractDOMParser_Val_Always;
-*Val_Auto = *XML::Xercesc::AbstractDOMParser_Val_Auto;
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_AbstractDOMParser($self);
- delete $OWNER{$self};
- }
-}
-
-*reset = *XML::Xercesc::AbstractDOMParser_reset;
-*adoptDocument = *XML::Xercesc::AbstractDOMParser_adoptDocument;
-# hold a reference to the parser internally, so that the
-# document can exist after the parser has gone out of scope
-sub getDocument {
- my ($self) = @_;
- my $result = XML::Xercesc::AbstractDOMParser_getDocument($self);
-
- # the DOMDocument destructor will automatically delete this entry if we
- # store it using the underlying tied() object
- $XML::Xerces::REMEMBER{tied(% {$result})}->{__PARSER} = $self;
- return $result;
-}
-
-*getValidator = *XML::Xercesc::AbstractDOMParser_getValidator;
-*getValidationScheme = *XML::Xercesc::AbstractDOMParser_getValidationScheme;
-*getDoSchema = *XML::Xercesc::AbstractDOMParser_getDoSchema;
-*getValidationSchemaFullChecking = *XML::Xercesc::AbstractDOMParser_getValidationSchemaFullChecking;
-*getIdentityConstraintChecking = *XML::Xercesc::AbstractDOMParser_getIdentityConstraintChecking;
-*getErrorCount = *XML::Xercesc::AbstractDOMParser_getErrorCount;
-*getDoNamespaces = *XML::Xercesc::AbstractDOMParser_getDoNamespaces;
-*getExitOnFirstFatalError = *XML::Xercesc::AbstractDOMParser_getExitOnFirstFatalError;
-*getValidationConstraintFatal = *XML::Xercesc::AbstractDOMParser_getValidationConstraintFatal;
-*getCreateEntityReferenceNodes = *XML::Xercesc::AbstractDOMParser_getCreateEntityReferenceNodes;
-*getIncludeIgnorableWhitespace = *XML::Xercesc::AbstractDOMParser_getIncludeIgnorableWhitespace;
-*getExternalSchemaLocation = *XML::Xercesc::AbstractDOMParser_getExternalSchemaLocation;
-*getExternalNoNamespaceSchemaLocation = *XML::Xercesc::AbstractDOMParser_getExternalNoNamespaceSchemaLocation;
-*getSecurityManager = *XML::Xercesc::AbstractDOMParser_getSecurityManager;
-*getLoadExternalDTD = *XML::Xercesc::AbstractDOMParser_getLoadExternalDTD;
-*getCreateCommentNodes = *XML::Xercesc::AbstractDOMParser_getCreateCommentNodes;
-*getCalculateSrcOfs = *XML::Xercesc::AbstractDOMParser_getCalculateSrcOfs;
-*getStandardUriConformant = *XML::Xercesc::AbstractDOMParser_getStandardUriConformant;
-*getPSVIHandler = *XML::Xercesc::AbstractDOMParser_getPSVIHandler;
-*getCreateSchemaInfo = *XML::Xercesc::AbstractDOMParser_getCreateSchemaInfo;
-*getGenerateSyntheticAnnotations = *XML::Xercesc::AbstractDOMParser_getGenerateSyntheticAnnotations;
-*getValidateAnnotations = *XML::Xercesc::AbstractDOMParser_getValidateAnnotations;
-*getIgnoreAnnotations = *XML::Xercesc::AbstractDOMParser_getIgnoreAnnotations;
-*getDisableDefaultEntityResolution = *XML::Xercesc::AbstractDOMParser_getDisableDefaultEntityResolution;
-*getSkipDTDValidation = *XML::Xercesc::AbstractDOMParser_getSkipDTDValidation;
-*setGenerateSyntheticAnnotations = *XML::Xercesc::AbstractDOMParser_setGenerateSyntheticAnnotations;
-*setValidateAnnotations = *XML::Xercesc::AbstractDOMParser_setValidateAnnotations;
-*setDoNamespaces = *XML::Xercesc::AbstractDOMParser_setDoNamespaces;
-*setExitOnFirstFatalError = *XML::Xercesc::AbstractDOMParser_setExitOnFirstFatalError;
-*setValidationConstraintFatal = *XML::Xercesc::AbstractDOMParser_setValidationConstraintFatal;
-*setCreateEntityReferenceNodes = *XML::Xercesc::AbstractDOMParser_setCreateEntityReferenceNodes;
-*setIncludeIgnorableWhitespace = *XML::Xercesc::AbstractDOMParser_setIncludeIgnorableWhitespace;
-*setValidationScheme = *XML::Xercesc::AbstractDOMParser_setValidationScheme;
-*setDoSchema = *XML::Xercesc::AbstractDOMParser_setDoSchema;
-*setValidationSchemaFullChecking = *XML::Xercesc::AbstractDOMParser_setValidationSchemaFullChecking;
-*setIdentityConstraintChecking = *XML::Xercesc::AbstractDOMParser_setIdentityConstraintChecking;
-*setExternalSchemaLocation = *XML::Xercesc::AbstractDOMParser_setExternalSchemaLocation;
-*setExternalNoNamespaceSchemaLocation = *XML::Xercesc::AbstractDOMParser_setExternalNoNamespaceSchemaLocation;
-*setSecurityManager = *XML::Xercesc::AbstractDOMParser_setSecurityManager;
-*setLoadExternalDTD = *XML::Xercesc::AbstractDOMParser_setLoadExternalDTD;
-*setCreateCommentNodes = *XML::Xercesc::AbstractDOMParser_setCreateCommentNodes;
-*setCalculateSrcOfs = *XML::Xercesc::AbstractDOMParser_setCalculateSrcOfs;
-*setStandardUriConformant = *XML::Xercesc::AbstractDOMParser_setStandardUriConformant;
-*useScanner = *XML::Xercesc::AbstractDOMParser_useScanner;
-*useImplementation = *XML::Xercesc::AbstractDOMParser_useImplementation;
-*setPSVIHandler = *XML::Xercesc::AbstractDOMParser_setPSVIHandler;
-*setCreateSchemaInfo = *XML::Xercesc::AbstractDOMParser_setCreateSchemaInfo;
-*setIgnoreAnnotations = *XML::Xercesc::AbstractDOMParser_setIgnoreAnnotations;
-*setDisableDefaultEntityResolution = *XML::Xercesc::AbstractDOMParser_setDisableDefaultEntityResolution;
-*setSkipDTDValidation = *XML::Xercesc::AbstractDOMParser_setSkipDTDValidation;
-*parse = *XML::Xercesc::AbstractDOMParser_parse;
-*parseFirst = *XML::Xercesc::AbstractDOMParser_parseFirst;
-*parseNext = *XML::Xercesc::AbstractDOMParser_parseNext;
-*parseReset = *XML::Xercesc::AbstractDOMParser_parseReset;
-*handleElementPSVI = *XML::Xercesc::AbstractDOMParser_handleElementPSVI;
-*handlePartialElementPSVI = *XML::Xercesc::AbstractDOMParser_handlePartialElementPSVI;
-*handleAttributesPSVI = *XML::Xercesc::AbstractDOMParser_handleAttributesPSVI;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
-############# Class : XML::Xerces::XercesDOMParser ##############
-
-package XML::Xerces::XercesDOMParser;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::AbstractDOMParser XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_XercesDOMParser(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_XercesDOMParser($self);
- delete $OWNER{$self};
- }
-}
-
-*getErrorHandler = *XML::Xercesc::XercesDOMParser_getErrorHandler;
-*getEntityResolver = *XML::Xercesc::XercesDOMParser_getEntityResolver;
-*getXMLEntityResolver = *XML::Xercesc::XercesDOMParser_getXMLEntityResolver;
-*isCachingGrammarFromParse = *XML::Xercesc::XercesDOMParser_isCachingGrammarFromParse;
-*isUsingCachedGrammarInParse = *XML::Xercesc::XercesDOMParser_isUsingCachedGrammarInParse;
-*getGrammar = *XML::Xercesc::XercesDOMParser_getGrammar;
-*getRootGrammar = *XML::Xercesc::XercesDOMParser_getRootGrammar;
-*getURIText = *XML::Xercesc::XercesDOMParser_getURIText;
-*getSrcOffset = *XML::Xercesc::XercesDOMParser_getSrcOffset;
-*getIgnoreCachedDTD = *XML::Xercesc::XercesDOMParser_getIgnoreCachedDTD;
-sub setErrorHandler {
- my ($self,$handler) = @_;
- my $callback = XML::Xerces::PerlErrorCallbackHandler->new($handler);
- $XML::Xerces::REMEMBER{tied(% {$self})}->{__ERROR_HANDLER} = $callback;
-
- return XML::Xercesc::XercesDOMParser_setErrorHandler($self,$callback);
-}
-
-sub setEntityResolver {
- my ($self,$handler) = @_;
- my $callback = XML::Xerces::PerlEntityResolverHandler->new($handler);
- $XML::Xerces::REMEMBER{tied(% {$self})}->{__ENTITY_RESOLVER} = $callback;
-
- return XML::Xercesc::XercesDOMParser_setEntityResolver($self,$callback);
-}
-
-*setXMLEntityResolver = *XML::Xercesc::XercesDOMParser_setXMLEntityResolver;
-*cacheGrammarFromParse = *XML::Xercesc::XercesDOMParser_cacheGrammarFromParse;
-*useCachedGrammarInParse = *XML::Xercesc::XercesDOMParser_useCachedGrammarInParse;
-*setIgnoreCachedDTD = *XML::Xercesc::XercesDOMParser_setIgnoreCachedDTD;
-*resetDocumentPool = *XML::Xercesc::XercesDOMParser_resetDocumentPool;
-*error = *XML::Xercesc::XercesDOMParser_error;
-*resetErrors = *XML::Xercesc::XercesDOMParser_resetErrors;
-*loadGrammar = *XML::Xercesc::XercesDOMParser_loadGrammar;
-*resetCachedGrammarPool = *XML::Xercesc::XercesDOMParser_resetCachedGrammarPool;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
############# Class : XML::Xerces::Parser ##############
package XML::Xerces::Parser;
@@ -6890,7 +4173,6 @@ sub DESTROY {
*type = *XML::Xercesc::PerlCallbackHandler_type;
*set_callback_obj = *XML::Xercesc::PerlCallbackHandler_set_callback_obj;
-*XMLString2Perl = *XML::Xercesc::PerlCallbackHandler_XMLString2Perl;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -6981,45 +4263,6 @@ sub ACQUIRE {
}
-############# Class : XML::Xerces::PerlNodeFilterCallbackHandler ##############
-
-package XML::Xerces::PerlNodeFilterCallbackHandler;
-use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
-@ISA = qw( XML::Xerces::DOMNodeFilter XML::Xerces::PerlCallbackHandler XML::Xerces );
-%OWNER = ();
-%ITERATORS = ();
-sub new {
- my $pkg = shift;
- my $self = XML::Xercesc::new_PerlNodeFilterCallbackHandler(@_);
- bless $self, $pkg if defined($self);
-}
-
-sub DESTROY {
- return unless $_[0]->isa('HASH');
- my $self = tied(%{$_[0]});
- return unless defined $self;
- delete $ITERATORS{$self};
- if (exists $OWNER{$self}) {
- XML::Xercesc::delete_PerlNodeFilterCallbackHandler($self);
- delete $OWNER{$self};
- }
-}
-
-*type = *XML::Xercesc::PerlNodeFilterCallbackHandler_type;
-*acceptNode = *XML::Xercesc::PerlNodeFilterCallbackHandler_acceptNode;
-sub DISOWN {
- my $self = shift;
- my $ptr = tied(%$self);
- delete $OWNER{$ptr};
-}
-
-sub ACQUIRE {
- my $self = shift;
- my $ptr = tied(%$self);
- $OWNER{$ptr} = 1;
-}
-
-
############# Class : XML::Xerces::PerlDocumentCallbackHandler ##############
package XML::Xerces::PerlDocumentCallbackHandler;
diff --git a/swig/perl/samples/DOM2hash.pl b/swig/perl/samples/DOM2hash.pl
index a66295498..8bb993542 100644
--- a/swig/perl/samples/DOM2hash.pl
+++ b/swig/perl/samples/DOM2hash.pl
@@ -15,6 +15,7 @@
#
use XML::Xerces qw(error);
+use XML::Xerces::DOM;
use Getopt::Long;
use Data::Dumper;
use strict;
diff --git a/swig/perl/samples/DOMCount.pl b/swig/perl/samples/DOMCount.pl
index a19de040f..12b573b76 100644
--- a/swig/perl/samples/DOMCount.pl
+++ b/swig/perl/samples/DOMCount.pl
@@ -64,7 +64,7 @@
######################################################################
use strict;
-use XML::Xerces;
+use XML::Xerces::DOM;
use Getopt::Long;
use Benchmark;
use vars qw(%OPTIONS);
diff --git a/swig/perl/samples/DOMCreate.pl b/swig/perl/samples/DOMCreate.pl
index 3e352227f..676bbf261 100644
--- a/swig/perl/samples/DOMCreate.pl
+++ b/swig/perl/samples/DOMCreate.pl
@@ -25,7 +25,7 @@
use strict;
# use blib;
-use XML::Xerces;
+use XML::Xerces::DOM;
# NOTICE: We must now explicitly call XMLPlatformUtils::Initialize()
# when the module is loaded. Xerces.pm no longer does this.
diff --git a/swig/perl/samples/DOMPrint.pl b/swig/perl/samples/DOMPrint.pl
index 9be8df688..520deef05 100644
--- a/swig/perl/samples/DOMPrint.pl
+++ b/swig/perl/samples/DOMPrint.pl
@@ -68,7 +68,7 @@
use strict;
# use blib;
-use XML::Xerces;
+use XML::Xerces::DOM;
use Getopt::Long;
use vars qw();
diff --git a/swig/perl/samples/validator-dom.pl b/swig/perl/samples/validator-dom.pl
index 940a93699..950b04dd1 100644
--- a/swig/perl/samples/validator-dom.pl
+++ b/swig/perl/samples/validator-dom.pl
@@ -32,7 +32,7 @@ sub fatal_error {
package main;
use strict;
# use blib;
-use XML::Xerces;
+use XML::Xerces::DOM;
use IO::Handle;
use Getopt::Long;
diff --git a/swig/perl/t/00dom_module.t b/swig/perl/t/00dom_module.t
new file mode 100644
index 000000000..141f15a93
--- /dev/null
+++ b/swig/perl/t/00dom_module.t
@@ -0,0 +1,33 @@
+# Before `make install' is performed this script should be runnable
+# with `make test'. After `make install' it should work as `perl
+# 00dom_module.t'
+
+END {fail("module loaded") unless $loaded;}
+
+use Carp;
+# use blib;
+use Test::More tests => 3;
+BEGIN { use_ok(XML::Xerces::DOM) };
+
+use vars qw($loaded);
+use strict;
+
+$loaded = 1;
+
+ # NOTICE: We must now explicitly call XMLPlatformUtils::Initialize()
+ # when the module is loaded. Xerces.pm no longer does this.
+ #
+ #
+XML::Xerces::XMLPlatformUtils::Initialize();
+
+pass("module initialized");
+
+ # NOTICE: We must now explicitly call XMLPlatformUtils::Terminate()
+ # when the module is unloaded. Xerces.pm no longer does this for us
+ #
+ #
+XML::Xerces::XMLPlatformUtils::Terminate();
+
+pass("module terminated");
+
+
diff --git a/swig/perl/t/00module.t b/swig/perl/t/00module.t
new file mode 100644
index 000000000..a31a84b33
--- /dev/null
+++ b/swig/perl/t/00module.t
@@ -0,0 +1,33 @@
+# Before `make install' is performed this script should be runnable
+# with `make test'. After `make install' it should work as `perl
+# 00module.t'
+
+END {fail("module loaded") unless $loaded;}
+
+use Carp;
+# use blib;
+use Test::More tests => 3;
+BEGIN { use_ok(XML::Xerces) };
+
+use vars qw($loaded);
+use strict;
+
+$loaded = 1;
+
+ # NOTICE: We must now explicitly call XMLPlatformUtils::Initialize()
+ # when the module is loaded. Xerces.pm no longer does this.
+ #
+ #
+XML::Xerces::XMLPlatformUtils::Initialize();
+
+pass("module initialized");
+
+ # NOTICE: We must now explicitly call XMLPlatformUtils::Terminate()
+ # when the module is unloaded. Xerces.pm no longer does this for us
+ #
+ #
+XML::Xerces::XMLPlatformUtils::Terminate();
+
+pass("module terminated");
+
+
diff --git a/swig/perl/t/01utf8.t b/swig/perl/t/01utf8.t
index dac2cd716..bbd4ed2e8 100644
--- a/swig/perl/t/01utf8.t
+++ b/swig/perl/t/01utf8.t
@@ -1,13 +1,22 @@
+# Before `make install' is performed this script should be runnable
+# with `make test'. After `make install' it should work as `perl
+# UTF8.t'
+
+######################### Begin module loading
+
# use blib;
-use XML::Xerces;
-use Cwd;
+
use Test::More tests => 42;
use vars qw($text);
use utf8;
use lib 't';
use TestUtils qw($PERSONAL_NO_DOCTYPE);
-pass("loaded");
+BEGIN { use_ok("XML::Xerces") };
+
+use strict;
+
+######################### Begin Test
# NOTICE: We must now explicitly call XMLPlatformUtils::Initialize()
# when the module is loaded. Xerces.pm no longer does this.
diff --git a/swig/perl/t/Attributes.t b/swig/perl/t/Attributes.t
index b07912309..0e423ae77 100644
--- a/swig/perl/t/Attributes.t
+++ b/swig/perl/t/Attributes.t
@@ -2,38 +2,19 @@
# with `make test'. After `make install' it should work as `perl
# Attributes.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-# Change 1..1 below to 1..last_test_to_print .
-# (It may become useful if the test is moved to ./t subdirectory.)
-
-END {fail() unless $loaded;}
-
-use Carp;
-use blib;
-use XML::Xerces;
+# use blib;
use Test::More tests => 19;
-use Config;
+BEGIN { use_ok("XML::Xerces") };
-use lib 't';
-use TestUtils qw($PERSONAL_FILE_NAME);
-use vars qw($i $loaded);
use strict;
-$loaded = 1;
-$i = 1;
-pass("module loaded");
-
-######################### End of black magic.
-
-# Insert your test code below (better if it prints "ok 13"
-# (correspondingly "not ok 13") depending on the success of chunk 13
-# of the test code):
+######################### Begin Test
package MyContentHandler;
use strict;
-use vars qw(@ISA);
-@ISA = qw(XML::Xerces::PerlContentHandler);
+use base qw(XML::Xerces::PerlContentHandler);
sub start_element {
my ($self,$uri,$localname,$qname,$attrs) = @_;
@@ -193,8 +174,7 @@ $document = qq[<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
package MyEntityResolver;
use strict;
-use vars qw(@ISA);
-@ISA = qw(XML::Xerces::PerlEntityResolver);
+use base qw(XML::Xerces::PerlEntityResolver);
sub new {
return bless {}, shift;
diff --git a/swig/perl/t/DOMAttr.t b/swig/perl/t/DOMAttr.t
index 48755b20f..82ce66830 100644
--- a/swig/perl/t/DOMAttr.t
+++ b/swig/perl/t/DOMAttr.t
@@ -2,29 +2,18 @@
# with `make test'. After `make install' it should work as `perl
# DOMAttr.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-END {fail() unless $loaded;}
-
-use Carp;
# use blib;
use utf8;
-use XML::Xerces;
use Test::More tests => 6;
+BEGIN { use_ok("XML::Xerces::DOM") };
use lib 't';
use TestUtils qw($DOM $PERSONAL_FILE_NAME);
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
-
-# Insert your test code below (better if it prints "ok 13"
-# (correspondingly "not ok 13") depending on the success of chunk 13
-# of the test code):
+######################### Begin Test
eval{$DOM->parse($PERSONAL_FILE_NAME)};
XML::Xerces::error($@) if $@;
@@ -32,18 +21,21 @@ XML::Xerces::error($@) if $@;
my $doc = $DOM->getDocument();
my $doctype = $doc->getDoctype();
my @persons = $doc->getElementsByTagName('person');
-ok(UNIVERSAL::isa($persons[0],'XML::Xerces::DOMElement'));
+isa_ok($persons[0],'XML::Xerces::DOMElement');
# test getting the attribute node
my $attr = $persons[0]->getAttributeNode('id');
-ok(UNIVERSAL::isa($attr,'XML::Xerces::DOMAttr'));
+isa_ok($attr,'XML::Xerces::DOMAttr');
# test getting the attribute value
-ok($attr->getValue() eq $persons[0]->getAttribute('id'));
+is($attr->getValue(), $persons[0]->getAttribute('id'),
+ 'getValue()');
# test that we can use integers and floats as values for setting attribtes
eval {$attr->setValue(3)};
-ok(!$@);
+ok(!$@,
+ 'setValue() of int');
-eval {$attr->setValue(.03)};
-ok(!$@);
+eval {$attr->setValue(0.03)};
+ok(!$@,
+ 'setValue() of float');
diff --git a/swig/perl/t/DOMBuilder.t b/swig/perl/t/DOMBuilder.t
index 94453048c..ba2147691 100644
--- a/swig/perl/t/DOMBuilder.t
+++ b/swig/perl/t/DOMBuilder.t
@@ -7,7 +7,7 @@
# use blib;
use Test::More tests => 12;
-BEGIN{use_ok('XML::Xerces')};
+BEGIN{use_ok('XML::Xerces::DOM')};
use lib 't';
use TestUtils qw($PERSONAL_FILE_NAME);
diff --git a/swig/perl/t/DOMConfig.t b/swig/perl/t/DOMConfig.t
index aff7800f9..6b0cebbc5 100644
--- a/swig/perl/t/DOMConfig.t
+++ b/swig/perl/t/DOMConfig.t
@@ -7,7 +7,7 @@
# use blib;
use Test::More tests => 20;
-BEGIN{use_ok('XML::Xerces')};
+BEGIN{use_ok('XML::Xerces::DOM')};
use lib 't';
use TestUtils qw($PERSONAL_FILE_NAME);
diff --git a/swig/perl/t/DOMCount.t b/swig/perl/t/DOMCount.t
index 655f483c5..5752647c4 100644
--- a/swig/perl/t/DOMCount.t
+++ b/swig/perl/t/DOMCount.t
@@ -2,28 +2,18 @@
# with `make test'. After `make install' it should work as `perl
# DOMCount.t
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-# Change 1..1 below to 1..last_test_to_print .
-# (It may become useful if the test is moved to ./t subdirectory.)
-
-END {fail() unless $loaded;}
-
-use Carp;
# use blib;
-use XML::Xerces;
-use Test::More tests => 2;
+use Test::More tests => 1;
use Config;
use lib 't';
use TestUtils qw($SAMPLE_DIR);
-use vars qw($loaded $file);
+use vars qw($file);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
+######################### Begin Test
my $document = q[<?xml version="1.0" encoding="UTF-8"?>
<contributors>
@@ -52,6 +42,6 @@ $perl =~ s/^\#!//;
my $output = `$perl -Mblib $SAMPLE_DIR/DOMCount.pl $file 2>/dev/null`;
# print STDERR "Out <$output>\n";
$output =~ /(\d+) elems/;
-ok($1 == 10, 'element count');
+is($1, 10, 'element count');
END {unlink $file;}
diff --git a/swig/perl/t/DOMCreate.t b/swig/perl/t/DOMCreate.t
index ae58693cd..cbd66ef76 100644
--- a/swig/perl/t/DOMCreate.t
+++ b/swig/perl/t/DOMCreate.t
@@ -2,25 +2,18 @@
# with `make test'. After `make install' it should work as `perl
# DOMCreate.t'
-######################### We start with some black magic to print on failure.
-
-END {fail() unless $loaded;}
+######################### Begin module loading
use Carp;
# use blib;
-use XML::Xerces;
-use Test::More tests => 2;
+use Test::More tests => 1;
use Config;
use lib 't';
use TestUtils qw($SAMPLE_DIR);
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
+######################### Begin Test
my $document = q[<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<!DOCTYPE contributors SYSTEM "contributors.dtd">
@@ -48,7 +41,7 @@ my $document = q[<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
my $perl = $Config{startperl};
$perl =~ s/^\#!//;
my $cmd = "$perl -Mblib $SAMPLE_DIR/DOMCreate.pl 2>/dev/null";
-print STDERR "Running: $cmd\n";
+# print STDERR "Running: $cmd\n";
my $output = `$cmd`;
is($document, $output,
diff --git a/swig/perl/t/DOMDocument.t b/swig/perl/t/DOMDocument.t
index 316f826a9..5d5d40643 100644
--- a/swig/perl/t/DOMDocument.t
+++ b/swig/perl/t/DOMDocument.t
@@ -2,29 +2,17 @@
# with `make test'. After `make install' it should work as `perl
# DOMDocument.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-# Change 1..1 below to 1..last_test_to_print .
-# (It may become useful if the test is moved to ./t subdirectory.)
-
-END {fail() unless $loaded;}
-
-use Carp;
-
-use blib;
+# use blib;
use utf8;
-use XML::Xerces;
use Test::More tests => 11;
-use Config;
+BEGIN{use_ok('XML::Xerces::DOM')};
use lib 't';
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
+######################### Begin Test
# Create a couple of identical test documents
my $document = q[<?xml version="1.0" encoding="UTF-8"?>
diff --git a/swig/perl/t/DOMElement.t b/swig/perl/t/DOMElement.t
index 58efdea55..6687fc222 100644
--- a/swig/perl/t/DOMElement.t
+++ b/swig/perl/t/DOMElement.t
@@ -2,24 +2,17 @@
# with `make test'. After `make install' it should work as `perl
# DOMElement.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-END {fail() unless $loaded;}
-
-use Carp;
use blib;
-use XML::Xerces;
use Test::More tests => 23;
+BEGIN { use_ok("XML::Xerces::DOM") };
use lib 't';
use TestUtils qw($DOM $PERSONAL_FILE_NAME);
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
+######################### Begin Test
$DOM->parse($PERSONAL_FILE_NAME);
diff --git a/swig/perl/t/DOMEntity.t b/swig/perl/t/DOMEntity.t
index 868aee4fa..6104a897b 100644
--- a/swig/perl/t/DOMEntity.t
+++ b/swig/perl/t/DOMEntity.t
@@ -2,24 +2,17 @@
# with `make test'. After `make install' it should work as `perl
# DOMEntity.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-END {fail() unless $loaded;}
-
-use Carp;
# use blib;
-use XML::Xerces;
use Test::More tests => 4;
+BEGIN { use_ok("XML::Xerces::DOM") };
use lib 't';
use TestUtils qw($DOM);
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
+######################### Begin Test
my $document = <<'EOT';
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
diff --git a/swig/perl/t/DOMException.t b/swig/perl/t/DOMException.t
index acd7ab843..d50e672d0 100644
--- a/swig/perl/t/DOMException.t
+++ b/swig/perl/t/DOMException.t
@@ -2,33 +2,12 @@
# with `make test'. After `make install' it should work as `perl
# DOMException.t'
-######################### We start with some black magic to print on failure.
-
-# Change 1..1 below to 1..last_test_to_print .
-# (It may become useful if the test is moved to ./t subdirectory.)
-
-END {fail() unless $loaded;}
-
-use Carp;
# use blib;
-use XML::Xerces;
use Test::More tests => 19;
-use Config;
+BEGIN {use_ok("XML::Xerces::DOM")};
-use lib 't';
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
-
-# Insert your test code below (better if it prints "ok 13"
-# (correspondingly "not ok 13") depending on the success of chunk 13
-# of the test code):
-
-
# NOTICE: We must now explicitly call XMLPlatformUtils::Initialize()
# when the module is loaded. Xerces.pm no longer does this.
#
diff --git a/swig/perl/t/DOMImplementation.t b/swig/perl/t/DOMImplementation.t
index 7c978b610..0879784aa 100644
--- a/swig/perl/t/DOMImplementation.t
+++ b/swig/perl/t/DOMImplementation.t
@@ -2,22 +2,17 @@
# with `make test'. After `make install' it should work as `perl
# DOMImplementation.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-END {fail("module loaded") unless $loaded;}
-
-use Carp;
# use blib;
use Test::More tests => 6;
-use XML::Xerces;
+BEGIN { use_ok("XML::Xerces::DOM") };
use lib 't';
use TestUtils qw($PERSONAL_FILE_NAME $PERSONAL_NO_DOCTYPE $PERSONAL $DOM);
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
+######################### Begin Test
# NOTICE: We must now explicitly call XMLPlatformUtils::Initialize()
# when the module is loaded. Xerces.pm no longer does this.
@@ -25,8 +20,6 @@ pass("module loaded");
#
XML::Xerces::XMLPlatformUtils::Initialize();
-######################### End of black magic.
-
my $domImpl = XML::Xerces::DOMImplementationRegistry::getDOMImplementation('LS');
isa_ok($domImpl,"XML::Xerces::DOMImplementation");
diff --git a/swig/perl/t/DOMNamedNodeMap.t b/swig/perl/t/DOMNamedNodeMap.t
index da4a898b2..1d313daa4 100644
--- a/swig/perl/t/DOMNamedNodeMap.t
+++ b/swig/perl/t/DOMNamedNodeMap.t
@@ -2,30 +2,16 @@
# with `make test'. After `make install' it should work as `perl
# DOMNamedNodeMap.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-# Change 1..1 below to 1..last_test_to_print .
-# (It may become useful if the test is moved to ./t subdirectory.)
-
-END {fail() unless $loaded;}
-
-use Carp;
-use XML::Xerces;
use Test::More tests => 15;
+BEGIN { use_ok("XML::Xerces::DOM") };
use lib 't';
use TestUtils qw($DOM);
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
-
-# Insert your test code below (better if it prints "ok 13"
-# (correspondingly "not ok 13") depending on the success of chunk 13
-# of the test code):
+######################### Begin Test
my $document = <<EOT;
<list>
diff --git a/swig/perl/t/DOMNode.t b/swig/perl/t/DOMNode.t
index 5b042dd54..dda840ae6 100644
--- a/swig/perl/t/DOMNode.t
+++ b/swig/perl/t/DOMNode.t
@@ -2,24 +2,15 @@
# with `make test'. After `make install' it should work as `perl
# DOMNode.t'
-######################### We start with some black magic to print on failure.
-
-END {fail() unless $loaded;}
-
-use Carp;
+######################### Begin module loading
# use blib;
use XML::Xerces;
use Test::More tests => 5;
-use Config;
-
-use vars qw($loaded);
+BEGIN { use_ok("XML::Xerces::DOM") };
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
+######################### Begin Test
# Create a couple of identical test documents
my $document = q[<?xml version="1.0" encoding="UTF-8"?>
diff --git a/swig/perl/t/DOMNodeIterator.t b/swig/perl/t/DOMNodeIterator.t
index b071c6122..8ee52a3e6 100644
--- a/swig/perl/t/DOMNodeIterator.t
+++ b/swig/perl/t/DOMNodeIterator.t
@@ -2,22 +2,14 @@
# with `make test'. After `make install' it should work as `perl
# DOMNodeIterator.t'
-######################### We start with some black magic to print on failure.
-
-END {fail() unless $loaded;}
-
-use Carp;
+######################### Begin module loading
use blib;
-use XML::Xerces;
use Test::More tests => 7;
-use Config;
-
-use vars qw($loaded);
+BEGIN { use_ok("XML::Xerces::DOM") };
use strict;
-$loaded = 1;
-pass("module loaded");
+######################### Begin Test
package MyNodeFilter;
use strict;
@@ -30,8 +22,6 @@ sub acceptNode {
package main;
-######################### End of black magic.
-
# Create a couple of identical test documents
my $document = q[<?xml version="1.0" encoding="UTF-8"?>
<contributors>
diff --git a/swig/perl/t/DOMNodeList.t b/swig/perl/t/DOMNodeList.t
index 476ec7151..3d31172eb 100644
--- a/swig/perl/t/DOMNodeList.t
+++ b/swig/perl/t/DOMNodeList.t
@@ -1,43 +1,35 @@
# Before `make install' is performed this script should be runnable with
# `make test'. After `make install' it should work as `perl DOMNodeList.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-END {fail() unless $loaded;}
-
-use Carp;
-use Cwd;
# use blib;
-use XML::Xerces;
use Test::More tests => 10;
+BEGIN { use_ok("XML::Xerces::DOM") };
use lib 't';
use TestUtils qw($DOM $PERSONAL_FILE_NAME);
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
-
-# Insert your test code below (better if it prints "ok 13"
-# (correspondingly "not ok 13") depending on the success of chunk 13
-# of the test code):
+######################### Begin Test
$DOM->parse( new XML::Xerces::LocalFileInputSource($PERSONAL_FILE_NAME) );
my $doc = $DOM->getDocument();
# test automatic conversion to perl list
my @node_list = $doc->getElementsByTagName('person');
-ok(scalar @node_list == 6);
+is(scalar @node_list, 6,
+ 'automatic conversion from NodeList to perl array');
# test that we can still get a DOMNodeList object
my $dom_node_list = $doc->getElementsByTagName('person');
-ok(UNIVERSAL::isa($dom_node_list,'XML::Xerces::DOMNodeList'));
+isa_ok($dom_node_list,'XML::Xerces::DOMNodeList');
-ok($dom_node_list->getLength() == scalar @node_list);
+is($dom_node_list->getLength(), scalar @node_list,
+ 'NodeList length eq to perl array length');
+# this test's the overloaded == operator for DOMNode
for (my $i=0;$i<scalar @node_list;$i++) {
- ok($node_list[$i] == $dom_node_list->item($i));
+ ok($node_list[$i] == $dom_node_list->item($i),
+ "perl array element $i is the same Node as NodeList element $i");
}
diff --git a/swig/perl/t/DOMParser.t b/swig/perl/t/DOMParser.t
index 1514807fa..78bc07350 100644
--- a/swig/perl/t/DOMParser.t
+++ b/swig/perl/t/DOMParser.t
@@ -2,25 +2,18 @@
# with `make test'. After `make install' it should work as `perl
# DOMParser.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-END {fail() unless $loaded;}
-
-use Carp;
# use blib;
-use XML::Xerces qw(error);
use Test::More tests => 11;
-use Config;
+BEGIN { use_ok("XML::Xerces::DOM") };
use lib 't';
use TestUtils qw($PERSONAL_FILE_NAME);
-use vars qw($loaded $error);
+use vars qw($error);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
+######################### Begin Test
my $document = q[<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<contributors>
diff --git a/swig/perl/t/DOMPrint.t b/swig/perl/t/DOMPrint.t
index 4de12b6db..5a0b89d17 100644
--- a/swig/perl/t/DOMPrint.t
+++ b/swig/perl/t/DOMPrint.t
@@ -2,32 +2,18 @@
# with `make test'. After `make install' it should work as `perl
# DOMPrint.t
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-# Change 1..1 below to 1..last_test_to_print .
-# (It may become useful if the test is moved to ./t subdirectory.)
-
-END {fail() unless $loaded;}
-
-use Carp;
# use blib;
-use XML::Xerces;
-use Test::More tests => 2;
+use Test::More tests => 1;
use Config;
use lib 't';
use TestUtils qw($SAMPLE_DIR);
-use vars qw($loaded $file);
+use vars qw($file);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
-
-# Insert your test code below (better if it prints "ok 13"
-# (correspondingly "not ok 13") depending on the success of chunk 13
-# of the test code):
+######################### Begin Test
my $document = q[<?xml version="1.0" encoding="iso-8859-1" standalone="yes" ?>
<contributors>
diff --git a/swig/perl/t/DOMStringList.t b/swig/perl/t/DOMStringList.t
new file mode 100644
index 000000000..cc0e221d4
--- /dev/null
+++ b/swig/perl/t/DOMStringList.t
@@ -0,0 +1,58 @@
+# Before `make install' is performed this script should be runnable
+# with `make test'. After `make install' it should work as `perl
+# DOMStringList.t'
+
+######################### Begin module loading
+
+# use blib;
+use Test::More tests => 20;
+
+BEGIN{use_ok('XML::Xerces::DOM')};
+
+use strict;
+
+######################### Begin Test
+
+my $impl = XML::Xerces::DOMImplementationRegistry::getDOMImplementation('LS');
+my $DOM = $impl->createLSParser($XML::Xerces::DOMImplementationLS::MODE_SYNCHRONOUS,'');
+my $conf = $DOM->getDomConfig();
+isa_ok($conf, 'XML::Xerces::DOMConfiguration');
+
+my @param_names = ($XML::Xerces::XMLUni::fgDOMErrorHandler,
+ $XML::Xerces::XMLUni::fgDOMSchemaType,
+ $XML::Xerces::XMLUni::fgDOMSchemaLocation,
+ $XML::Xerces::XMLUni::fgDOMCanonicalForm,
+ $XML::Xerces::XMLUni::fgDOMCDATASections,
+ $XML::Xerces::XMLUni::fgDOMComments,
+ $XML::Xerces::XMLUni::fgDOMDatatypeNormalization,
+ $XML::Xerces::XMLUni::fgDOMWRTDiscardDefaultContent,
+ $XML::Xerces::XMLUni::fgDOMEntities,
+ $XML::Xerces::XMLUni::fgDOMInfoset,
+ $XML::Xerces::XMLUni::fgDOMNamespaces,
+ $XML::Xerces::XMLUni::fgDOMNamespaceDeclarations,
+ $XML::Xerces::XMLUni::fgDOMNormalizeCharacters,
+ $XML::Xerces::XMLUni::fgDOMSplitCDATASections,
+ $XML::Xerces::XMLUni::fgDOMValidate,
+ $XML::Xerces::XMLUni::fgDOMValidateIfSchema,
+ $XML::Xerces::XMLUni::fgDOMElementContentWhitespace);
+
+my @accepted_param_names = $conf->getParameterNames();
+ok(scalar @accepted_param_names, "StringList to_list()");
+
+my $accepted_params_list = $conf->getParameterNames();
+isa_ok($accepted_params_list, "XML::Xerces::DOMStringList");
+
+is($accepted_params_list->getLength(), scalar @accepted_param_names,
+ 'StringList length equal overload list length')
+ or diag("Found items: " . join(':', @accepted_param_names));
+
+my %param_names = map {$_=>1} @param_names;
+foreach my $param_name (@param_names) {
+ ok($accepted_params_list->contains($param_name),
+ "can set $param_name");
+}
+
+for (my $i=0; $i<$accepted_params_list->getLength(); $i++) {
+ my $param_name = $accepted_params_list->item($i);
+# is($accepted_param_names[$i], $param_name, "$param_name in StringList");
+}
diff --git a/swig/perl/t/DOMTreeWalker.t b/swig/perl/t/DOMTreeWalker.t
index f9b926663..633f82493 100644
--- a/swig/perl/t/DOMTreeWalker.t
+++ b/swig/perl/t/DOMTreeWalker.t
@@ -1,26 +1,16 @@
# Before `make install' is performed this script should be runnable
# with `make test'. After `make install' it should work as `perl
-# DOMNode.t'
+# DOMTreeWalker.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-# Change 1..1 below to 1..last_test_to_print .
-# (It may become useful if the test is moved to ./t subdirectory.)
-
-END {fail() unless $loaded;}
-
-use Carp;
# use blib;
-use XML::Xerces;
use Test::More tests => 7;
-use Config;
+BEGIN { use_ok("XML::Xerces::DOM") };
-use lib 't';
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
+######################### Begin Test
package MyNodeFilter;
use strict;
@@ -33,12 +23,6 @@ sub acceptNode {
package main;
-######################### End of black magic.
-
-# Insert your test code below (better if it prints "ok 13"
-# (correspondingly "not ok 13") depending on the success of chunk 13
-# of the test code):
-
# Create a couple of identical test documents
my $document = q[<?xml version="1.0" encoding="UTF-8"?>
<contributors>
diff --git a/swig/perl/t/DOMWriter.t b/swig/perl/t/DOMWriter.t
index ab1a8f43c..7f7625012 100644
--- a/swig/perl/t/DOMWriter.t
+++ b/swig/perl/t/DOMWriter.t
@@ -2,24 +2,15 @@
# with `make test'. After `make install' it should work as `perl
# DOMWriter.t'
-######################### We start with some black magic to print on failure.
-
-END {fail() unless $loaded;}
-
-use Carp;
+######################### Begin module loading
# use blib;
-use XML::Xerces;
use Test::More tests => 6;
-use Config;
+BEGIN { use_ok("XML::Xerces::DOM") };
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
+######################### Begin Test
# Create a couple of identical test documents
my $document = q[<?xml version="1.0" encoding="UTF-8" standalone="no" ?><contributors>
diff --git a/swig/perl/t/SAX2XMLReader.t b/swig/perl/t/SAX2XMLReader.t
index 113eb6764..76a24d054 100644
--- a/swig/perl/t/SAX2XMLReader.t
+++ b/swig/perl/t/SAX2XMLReader.t
@@ -2,25 +2,25 @@
# with `make test'. After `make install' it should work as `perl
# SAX2XMLReader.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-END {fail() unless $loaded;}
-
-use Carp;
# use blib;
-use XML::Xerces qw(error);
use Test::More tests => 26;
-use Config;
+BEGIN { use_ok("XML::Xerces") };
+use Carp;
use lib 't';
use TestUtils qw($PERSONAL_FILE_NAME $SCHEMA_FILE_NAME $PERSONAL_SCHEMA_INVALID_FILE_NAME);
-use vars qw($loaded $error);
+use vars qw($error);
use strict;
-$loaded = 1;
-pass("module loaded");
+######################### Begin Test
-######################### End of black magic.
+ # NOTICE: We must now explicitly call XMLPlatformUtils::Initialize()
+ # when the module is loaded. Xerces.pm no longer does this.
+ #
+ #
+XML::Xerces::XMLPlatformUtils::Initialize();
my $document = q[<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<contributors>
@@ -40,8 +40,7 @@ my $document = q[<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
package MyContentHandler;
use strict;
-use vars qw(@ISA);
-@ISA = qw(XML::Xerces::PerlContentHandler);
+use base qw(XML::Xerces::PerlContentHandler);
sub start_element {
my $self = shift;
@@ -93,15 +92,17 @@ ok((not $@),'setting dynamic=>yes')
$CONTENT_HANDLER->reset_document();
eval{$SAX->parse(XML::Xerces::MemBufInputSource->new($document, 'foo'))};
-ok((not $@),'membuf parse');
+ok((not $@),'membuf parse')
+ or diag(XML::Xerces::error($@));
is($CONTENT_HANDLER->{elements}, 10,'elements');
is($CONTENT_HANDLER->{chars}, 141,'chars');
is($CONTENT_HANDLER->{ws}, 0,'ws');
# test the overloaded parse version
-$SAX->parse($PERSONAL_FILE_NAME);
-pass('parse filename');
+eval{$SAX->parse($PERSONAL_FILE_NAME)};
+ok((not $@),'parse filename')
+ or diag(XML::Xerces::error($@));
# reset the counts
$CONTENT_HANDLER->reset_document();
@@ -161,8 +162,7 @@ $document = <<\END;
END
package MyErrorHandler;
use strict;
-use vars qw(@ISA);
-@ISA = qw(XML::Xerces::PerlErrorHandler);
+use base qw(XML::Xerces::PerlErrorHandler);
sub warning {
my $LINE = $_[1]->getLineNumber;
my $COLUMN = $_[1]->getColumnNumber;
@@ -312,3 +312,11 @@ eval {$SAX->parse($is)};
ok($@, "parse invalid doc with fgXercesSchemaExternalNoNameSpaceSchemaLocation set");
like($@, qr/Unknown element 'contributors'/, 'invalid document error');
+
+END {
+ # NOTICE: We must now explicitly call XMLPlatformUtils::Terminate()
+ # when the module is unloaded. Xerces.pm no longer does this for us
+ #
+ #
+ XML::Xerces::XMLPlatformUtils::Terminate();
+}
diff --git a/swig/perl/t/SAXException.t b/swig/perl/t/SAXException.t
index 43137a11d..ce02de3d9 100644
--- a/swig/perl/t/SAXException.t
+++ b/swig/perl/t/SAXException.t
@@ -2,26 +2,19 @@
# with `make test'. After `make install' it should work as `perl
# SAXException.t'
-######################### We start with some black magic to print on failure.
-
-END {fail() unless $loaded;}
-
-use Carp;
+######################### Begin module loading
# use blib;
-use XML::Xerces;
use Test::More tests => 17;
-use Config;
+BEGIN { use_ok("XML::Xerces") };
use lib 't';
-use TestUtils qw($PERSONAL_FILE_NAME);
-use vars qw($loaded);
+# use TestUtils qw($PERSONAL_FILE_NAME);
use strict;
-$loaded = 1;
-pass("module loaded");
+my $PERSONAL_FILE_NAME = 'samples/personal.xml';
-######################### End of black magic.
+######################### Begin Test
# test that we get an SAXNotRecognizedException
my $parser = XML::Xerces::XMLReaderFactory::createXMLReader();
@@ -77,8 +70,7 @@ SKIP: {
# test that modifying a feature during a parse raises a not supported exception
package MyHandler;
use strict;
-use vars qw(@ISA);
-@ISA = qw(XML::Xerces::PerlContentHandler);
+use base qw(XML::Xerces::PerlContentHandler);
sub start_element {
my ($self,$name,$attrs) = @_;
diff --git a/swig/perl/t/SAXParser.t b/swig/perl/t/SAXParser.t
index 594c5dbaf..16e5be545 100644
--- a/swig/perl/t/SAXParser.t
+++ b/swig/perl/t/SAXParser.t
@@ -2,25 +2,17 @@
# with `make test'. After `make install' it should work as `perl
# SAXParser.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-END {fail() unless $loaded;}
-
-use Carp;
-use blib;
-use XML::Xerces;
+# use blib;
use Test::More tests => 12;
-use Config;
+BEGIN { use_ok("XML::Xerces") };
use lib 't';
use TestUtils qw($PERSONAL_FILE_NAME);
-use vars qw($loaded $error);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
+######################### Begin Test
my $document = q[<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<contributors>
@@ -40,12 +32,12 @@ my $document = q[<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
package MyDocumentHandler;
use strict;
-use vars qw(@ISA);
-@ISA = qw(XML::Xerces::PerlDocumentHandler);
+use base qw(XML::Xerces::PerlDocumentHandler);
sub start_element {
- my $self = shift;
+ my ($self, $name, @attrs) = @_;
$self->{elements}++;
+ $self->{element}->{$name} = \@attrs;
}
sub characters {
my ($self,$str,$len) = @_;
@@ -75,9 +67,9 @@ $SAX->setErrorHandler($ERROR_HANDLER);
$DOCUMENT_HANDLER->reset_document();
$SAX->parse(XML::Xerces::MemBufInputSource->new($document, 'foo'));
-ok($DOCUMENT_HANDLER->{elements} == 10,'elements');
-ok($DOCUMENT_HANDLER->{chars} == 141,'chars');
-ok($DOCUMENT_HANDLER->{ws} == 0,'ws');
+is($DOCUMENT_HANDLER->{elements}, 10,'elements');
+is($DOCUMENT_HANDLER->{chars}, 141,'chars');
+is($DOCUMENT_HANDLER->{ws}, 0,'ws');
# test the overloaded parse version
$SAX->parse($PERSONAL_FILE_NAME);
diff --git a/swig/perl/t/TestUtils.pm b/swig/perl/t/TestUtils.pm
index 0eb6164ea..fe4e74919 100644
--- a/swig/perl/t/TestUtils.pm
+++ b/swig/perl/t/TestUtils.pm
@@ -1,5 +1,5 @@
package TestUtils;
-use XML::Xerces;
+use XML::Xerces::DOM;
use strict;
use vars qw($VERSION
@ISA
diff --git a/swig/perl/t/UTF8.t b/swig/perl/t/UTF8.t
index 451444bf5..7f84e0aee 100644
--- a/swig/perl/t/UTF8.t
+++ b/swig/perl/t/UTF8.t
@@ -2,26 +2,16 @@
# with `make test'. After `make install' it should work as `perl
# UTF8.t'
-######################### We start with some black magic to print on failure.
+######################### Begin module loading
-END {fail() unless $loaded;}
-
-use Carp;
-
-use blib;
+# use blib;
use utf8;
-use XML::Xerces;
use Test::More tests => 35119;
-use Config;
+BEGIN { use_ok("XML::Xerces::DOM") };
-use lib 't';
-use vars qw($loaded);
use strict;
-$loaded = 1;
-pass("module loaded");
-
-######################### End of black magic.
+######################### Begin Test
my $DOM1 = new XML::Xerces::XercesDOMParser;
my $ERROR_HANDLER = XML::Xerces::PerlErrorHandler->new();
diff --git a/swig/perl/t/XMLUni.t b/swig/perl/t/XMLUni.t
index bc933f7fa..deb7fd5bf 100644
--- a/swig/perl/t/XMLUni.t
+++ b/swig/perl/t/XMLUni.t
@@ -5,7 +5,7 @@
# use blib;
use Test::More tests => 5;
-BEGIN {use_ok("XML::Xerces")};
+BEGIN {use_ok("XML::Xerces::DOM")};
use strict;
diff --git a/swig/perl/xerces-swig-perl.hpp b/swig/perl/xerces-swig-perl.hpp
new file mode 100644
index 000000000..5bdc14997
--- /dev/null
+++ b/swig/perl/xerces-swig-perl.hpp
@@ -0,0 +1,1350 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.30
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ * This section contains generic SWIG labels for method/variable
+ * declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC)
+# if (__SUNPRO_CC <= 0x560)
+# define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+# define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+# else
+# define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+# define SWIGINLINE inline
+# else
+# define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+# define SWIGUNUSED __attribute__ ((__unused__))
+# else
+# define SWIGUNUSED
+# endif
+# elif defined(__ICC)
+# define SWIGUNUSED __attribute__ ((__unused__))
+# else
+# define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+# define SWIGUNUSEDPARM(p)
+# else
+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+# ifndef GCC_HASCLASSVISIBILITY
+# define GCC_HASCLASSVISIBILITY
+# endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+# if defined(STATIC_LINKED)
+# define SWIGEXPORT
+# else
+# define SWIGEXPORT __declspec(dllexport)
+# endif
+# else
+# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+# define SWIGEXPORT __attribute__ ((visibility("default")))
+# else
+# define SWIGEXPORT
+# endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+# define SWIGSTDCALL __stdcall
+# else
+# define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+/* Errors in SWIG */
+#define SWIG_UnknownError -1
+#define SWIG_IOError -2
+#define SWIG_RuntimeError -3
+#define SWIG_IndexError -4
+#define SWIG_TypeError -5
+#define SWIG_DivisionByZero -6
+#define SWIG_OverflowError -7
+#define SWIG_SyntaxError -8
+#define SWIG_ValueError -9
+#define SWIG_SystemError -10
+#define SWIG_AttributeError -11
+#define SWIG_MemoryError -12
+#define SWIG_NullReferenceError -13
+
+
+/* Errors in SWIG */
+#define SWIG_UnknownError -1
+#define SWIG_IOError -2
+#define SWIG_RuntimeError -3
+#define SWIG_IndexError -4
+#define SWIG_TypeError -5
+#define SWIG_DivisionByZero -6
+#define SWIG_OverflowError -7
+#define SWIG_SyntaxError -8
+#define SWIG_ValueError -9
+#define SWIG_SystemError -10
+#define SWIG_AttributeError -11
+#define SWIG_MemoryError -12
+#define SWIG_NullReferenceError -13
+
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic CAPI SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+ or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "3"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+ You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+ creating a static or dynamic library from the swig runtime code.
+ In 99.9% of the cases, swig just needs to declare them as 'static'.
+
+ But only do this if is strictly necessary, ie, if you have problems
+ with your compiler or so.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/* Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN 0x1
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN 0x1
+
+
+/*
+ Flags/methods for returning states.
+
+ The swig conversion methods, as ConvertPtr, return and integer
+ that tells if the conversion was successful or not. And if not,
+ an error code can be returned (see swigerrors.swg for the codes).
+
+ Use the following macros/flags to set or process the returning
+ states.
+
+ In old swig versions, you usually write code as:
+
+ if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+ // success code
+ } else {
+ //fail code
+ }
+
+ Now you can be more explicit as:
+
+ int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+ if (SWIG_IsOK(res)) {
+ // success code
+ } else {
+ // fail code
+ }
+
+ that seems to be the same, but now you can also do
+
+ Type *ptr;
+ int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+ if (SWIG_IsOK(res)) {
+ // success code
+ if (SWIG_IsNewObj(res) {
+ ...
+ delete *ptr;
+ } else {
+ ...
+ }
+ } else {
+ // fail code
+ }
+
+ I.e., now SWIG_ConvertPtr can return new objects and you can
+ identify the case and take care of the deallocation. Of course that
+ requires also to SWIG_ConvertPtr to return new result values, as
+
+ int SWIG_ConvertPtr(obj, ptr,...) {
+ if (<obj is ok>) {
+ if (<need new object>) {
+ *ptr = <ptr to new allocated object>;
+ return SWIG_NEWOBJ;
+ } else {
+ *ptr = <ptr to old object>;
+ return SWIG_OLDOBJ;
+ }
+ } else {
+ return SWIG_BADOBJ;
+ }
+ }
+
+ Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+ more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+ swig errors code.
+
+ Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+ allows to return the 'cast rank', for example, if you have this
+
+ int food(double)
+ int fooi(int);
+
+ and you call
+
+ food(1) // cast rank '1' (1 -> 1.0)
+ fooi(1) // cast rank '0'
+
+ just use the SWIG_AddCast()/SWIG_CheckState()
+
+
+ */
+#define SWIG_OK (0)
+#define SWIG_ERROR (-1)
+#define SWIG_IsOK(r) (r >= 0)
+#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ (SWIG_ERROR)
+#define SWIG_OLDOBJ (SWIG_OK)
+#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+# ifndef SWIG_TypeRank
+# define SWIG_TypeRank unsigned long
+# endif
+# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
+# define SWIG_MAXCASTRANK (2)
+# endif
+# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
+# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+ return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+# define SWIG_AddCast
+# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store inforomation on one type */
+typedef struct swig_type_info {
+ const char *name; /* mangled name of this type */
+ const char *str; /* human readable name of this type */
+ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
+ struct swig_cast_info *cast; /* linked list of types that can cast into this type */
+ void *clientdata; /* language specific type data */
+ int owndata; /* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+ swig_type_info *type; /* pointer to type that is equivalent to this type */
+ swig_converter_func converter; /* function to cast the void pointers */
+ struct swig_cast_info *next; /* pointer to next cast in linked list */
+ struct swig_cast_info *prev; /* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+ swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
+ size_t size; /* Number of types in this module */
+ struct swig_module_info *next; /* Pointer to next element in circularly linked list */
+ swig_type_info **type_initial; /* Array of initially generated type structures */
+ swig_cast_info **cast_initial; /* Array of initially generated casting structures */
+ void *clientdata; /* Language specific module data */
+} swig_module_info;
+
+/*
+ Compare two type names skipping the space characters, therefore
+ "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+ Return 0 when the two name types are equivalent, as in
+ strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+ const char *f2, const char *l2) {
+ for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+ while ((*f1 == ' ') && (f1 != l1)) ++f1;
+ while ((*f2 == ' ') && (f2 != l2)) ++f2;
+ if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+ }
+ return (l1 - f1) - (l2 - f2);
+}
+
+/*
+ Check type equivalence in a name list like <name1>|<name2>|...
+ Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+ int equiv = 0;
+ const char* te = tb + strlen(tb);
+ const char* ne = nb;
+ while (!equiv && *ne) {
+ for (nb = ne; *ne; ++ne) {
+ if (*ne == '|') break;
+ }
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+ if (*ne) ++ne;
+ }
+ return equiv;
+}
+
+/*
+ Check type equivalence in a name list like <name1>|<name2>|...
+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCompare(const char *nb, const char *tb) {
+ int equiv = 0;
+ const char* te = tb + strlen(tb);
+ const char* ne = nb;
+ while (!equiv && *ne) {
+ for (nb = ne; *ne; ++ne) {
+ if (*ne == '|') break;
+ }
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+ if (*ne) ++ne;
+ }
+ return equiv;
+}
+
+
+/* think of this as a c++ template<> or a scheme macro */
+#define SWIG_TypeCheck_Template(comparison, ty) \
+ if (ty) { \
+ swig_cast_info *iter = ty->cast; \
+ while (iter) { \
+ if (comparison) { \
+ if (iter == ty->cast) return iter; \
+ /* Move iter to the top of the linked list */ \
+ iter->prev->next = iter->next; \
+ if (iter->next) \
+ iter->next->prev = iter->prev; \
+ iter->next = ty->cast; \
+ iter->prev = 0; \
+ if (ty->cast) ty->cast->prev = iter; \
+ ty->cast = iter; \
+ return iter; \
+ } \
+ iter = iter->next; \
+ } \
+ } \
+ return 0
+
+/*
+ Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+ SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
+}
+
+/* Same as previous function, except strcmp is replaced with a pointer comparison */
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
+ SWIG_TypeCheck_Template(iter->type == from, into);
+}
+
+/*
+ Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
+ return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
+}
+
+/*
+ Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+ swig_type_info *lastty = ty;
+ if (!ty || !ty->dcast) return ty;
+ while (ty && (ty->dcast)) {
+ ty = (*ty->dcast)(ptr);
+ if (ty) lastty = ty;
+ }
+ return lastty;
+}
+
+/*
+ Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+ return ty->name;
+}
+
+/*
+ Return the pretty name associated with this type,
+ that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+ /* The "str" field contains the equivalent pretty names of the
+ type, separated by vertical-bar characters. We choose
+ to print the last name, as it is often (?) the most
+ specific. */
+ if (!type) return NULL;
+ if (type->str != NULL) {
+ const char *last_name = type->str;
+ const char *s;
+ for (s = type->str; *s; s++)
+ if (*s == '|') last_name = s+1;
+ return last_name;
+ }
+ else
+ return type->name;
+}
+
+/*
+ Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+ swig_cast_info *cast = ti->cast;
+ /* if (ti->clientdata == clientdata) return; */
+ ti->clientdata = clientdata;
+
+ while (cast) {
+ if (!cast->converter) {
+ swig_type_info *tc = cast->type;
+ if (!tc->clientdata) {
+ SWIG_TypeClientData(tc, clientdata);
+ }
+ }
+ cast = cast->next;
+ }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+ SWIG_TypeClientData(ti, clientdata);
+ ti->owndata = 1;
+}
+
+/*
+ Search for a swig_type_info structure only by mangled name
+ Search is a O(log #types)
+
+ We start searching at module start, and finish searching when start == end.
+ Note: if start == end at the beginning of the function, we go all the way around
+ the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
+ const char *name) {
+ swig_module_info *iter = start;
+ do {
+ if (iter->size) {
+ register size_t l = 0;
+ register size_t r = iter->size - 1;
+ do {
+ /* since l+r >= 0, we can (>> 1) instead (/ 2) */
+ register size_t i = (l + r) >> 1;
+ const char *iname = iter->types[i]->name;
+ if (iname) {
+ register int compare = strcmp(name, iname);
+ if (compare == 0) {
+ return iter->types[i];
+ } else if (compare < 0) {
+ if (i) {
+ r = i - 1;
+ } else {
+ break;
+ }
+ } else if (compare > 0) {
+ l = i + 1;
+ }
+ } else {
+ break; /* should never happen */
+ }
+ } while (l <= r);
+ }
+ iter = iter->next;
+ } while (iter != end);
+ return 0;
+}
+
+/*
+ Search for a swig_type_info structure for either a mangled name or a human readable name.
+ It first searches the mangled names of the types, which is a O(log #types)
+ If a type is not found it then searches the human readable names, which is O(#types).
+
+ We start searching at module start, and finish searching when start == end.
+ Note: if start == end at the beginning of the function, we go all the way around
+ the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
+ const char *name) {
+ /* STEP 1: Search the name field using binary search */
+ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+ if (ret) {
+ return ret;
+ } else {
+ /* STEP 2: If the type hasn't been found, do a complete search
+ of the str field (the human readable name) */
+ swig_module_info *iter = start;
+ do {
+ register size_t i = 0;
+ for (; i < iter->size; ++i) {
+ if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+ return iter->types[i];
+ }
+ iter = iter->next;
+ } while (iter != end);
+ }
+
+ /* neither found a match */
+ return 0;
+}
+
+/*
+ Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+ static const char hex[17] = "0123456789abcdef";
+ register const unsigned char *u = (unsigned char *) ptr;
+ register const unsigned char *eu = u + sz;
+ for (; u != eu; ++u) {
+ register unsigned char uu = *u;
+ *(c++) = hex[(uu & 0xf0) >> 4];
+ *(c++) = hex[uu & 0xf];
+ }
+ return c;
+}
+
+/*
+ Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+ register unsigned char *u = (unsigned char *) ptr;
+ register const unsigned char *eu = u + sz;
+ for (; u != eu; ++u) {
+ register char d = *(c++);
+ register unsigned char uu;
+ if ((d >= '0') && (d <= '9'))
+ uu = ((d - '0') << 4);
+ else if ((d >= 'a') && (d <= 'f'))
+ uu = ((d - ('a'-10)) << 4);
+ else
+ return (char *) 0;
+ d = *(c++);
+ if ((d >= '0') && (d <= '9'))
+ uu |= (d - '0');
+ else if ((d >= 'a') && (d <= 'f'))
+ uu |= (d - ('a'-10));
+ else
+ return (char *) 0;
+ *u = uu;
+ }
+ return c;
+}
+
+/*
+ Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+ char *r = buff;
+ if ((2*sizeof(void *) + 2) > bsz) return 0;
+ *(r++) = '_';
+ r = SWIG_PackData(r,&ptr,sizeof(void *));
+ if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+ strcpy(r,name);
+ return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+ if (*c != '_') {
+ if (strcmp(c,"NULL") == 0) {
+ *ptr = (void *) 0;
+ return name;
+ } else {
+ return 0;
+ }
+ }
+ return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+ char *r = buff;
+ size_t lname = (name ? strlen(name) : 0);
+ if ((2*sz + 2 + lname) > bsz) return 0;
+ *(r++) = '_';
+ r = SWIG_PackData(r,ptr,sz);
+ if (lname) {
+ strncpy(r,name,lname+1);
+ } else {
+ *r = 0;
+ }
+ return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+ if (*c != '_') {
+ if (strcmp(c,"NULL") == 0) {
+ memset(ptr,0,sz);
+ return name;
+ } else {
+ return 0;
+ }
+ }
+ return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+#ifdef __cplusplus
+/* Needed on some windows machines---since MS plays funny games with the header files under C++ */
+#include <math.h>
+#include <stdlib.h>
+extern "C" {
+#endif
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+/* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
+
+/* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
+#ifndef PERL_REVISION
+# if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
+# define PERL_PATCHLEVEL_H_IMPLICIT
+# include <patchlevel.h>
+# endif
+# if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
+# include <could_not_find_Perl_patchlevel.h>
+# endif
+# ifndef PERL_REVISION
+# define PERL_REVISION (5)
+# define PERL_VERSION PATCHLEVEL
+# define PERL_SUBVERSION SUBVERSION
+# endif
+#endif
+
+#if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
+#define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
+#endif
+
+#ifndef SvIOK_UV
+# define SvIOK_UV(sv) (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
+#endif
+
+#ifndef SvUOK
+# define SvUOK(sv) SvIOK_UV(sv)
+#endif
+
+#if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
+# define PL_sv_undef sv_undef
+# define PL_na na
+# define PL_errgv errgv
+# define PL_sv_no sv_no
+# define PL_sv_yes sv_yes
+# define PL_markstack_ptr markstack_ptr
+#endif
+
+#ifndef IVSIZE
+# ifdef LONGSIZE
+# define IVSIZE LONGSIZE
+# else
+# define IVSIZE 4 /* A bold guess, but the best we can make. */
+# endif
+#endif
+
+#ifndef INT2PTR
+# if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
+# define PTRV UV
+# define INT2PTR(any,d) (any)(d)
+# else
+# if PTRSIZE == LONGSIZE
+# define PTRV unsigned long
+# else
+# define PTRV unsigned
+# endif
+# define INT2PTR(any,d) (any)(PTRV)(d)
+# endif
+
+# define NUM2PTR(any,d) (any)(PTRV)(d)
+# define PTR2IV(p) INT2PTR(IV,p)
+# define PTR2UV(p) INT2PTR(UV,p)
+# define PTR2NV(p) NUM2PTR(NV,p)
+
+# if PTRSIZE == LONGSIZE
+# define PTR2ul(p) (unsigned long)(p)
+# else
+# define PTR2ul(p) INT2PTR(unsigned long,p)
+# endif
+#endif /* !INT2PTR */
+
+#ifndef get_sv
+# define get_sv perl_get_sv
+#endif
+
+#ifndef ERRSV
+# define ERRSV get_sv("@",FALSE)
+#endif
+
+#ifndef pTHX_
+#define pTHX_
+#endif
+
+#include <string.h>
+#ifdef __cplusplus
+}
+#endif
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+SWIGINTERN const char*
+SWIG_Perl_ErrorType(int code) {
+ const char* type = 0;
+ switch(code) {
+ case SWIG_MemoryError:
+ type = "MemoryError";
+ break;
+ case SWIG_IOError:
+ type = "IOError";
+ break;
+ case SWIG_RuntimeError:
+ type = "RuntimeError";
+ break;
+ case SWIG_IndexError:
+ type = "IndexError";
+ break;
+ case SWIG_TypeError:
+ type = "TypeError";
+ break;
+ case SWIG_DivisionByZero:
+ type = "ZeroDivisionError";
+ break;
+ case SWIG_OverflowError:
+ type = "OverflowError";
+ break;
+ case SWIG_SyntaxError:
+ type = "SyntaxError";
+ break;
+ case SWIG_ValueError:
+ type = "ValueError";
+ break;
+ case SWIG_SystemError:
+ type = "SystemError";
+ break;
+ case SWIG_AttributeError:
+ type = "AttributeError";
+ break;
+ default:
+ type = "RuntimeError";
+ }
+ return type;
+}
+
+
+
+/* -----------------------------------------------------------------------------
+ * perlrun.swg
+ *
+ * This file contains the runtime support for Perl modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef PERL_OBJECT
+#define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
+#define SWIG_PERL_OBJECT_CALL pPerl,
+#else
+#define SWIG_PERL_OBJECT_DECL
+#define SWIG_PERL_OBJECT_CALL
+#endif
+
+/* Common SWIG API */
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
+#define SWIG_NewPointerObj(p, type, flags) SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, p, s, type) SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
+#define SWIG_NewPackedObj(p, s, type) SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type) SWIG_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata) SWIG_Perl_GetModule()
+#define SWIG_SetModule(clientdata, pointer) SWIG_Perl_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code) SWIG_Perl_ErrorType(code)
+#define SWIG_Error(code, msg) sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg)
+#define SWIG_fail goto fail
+
+/* Perl-specific SWIG API */
+
+#define SWIG_MakePtr(sv, ptr, type, flags) SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
+#define SWIG_MakePackedObj(sv, p, s, type) SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
+#define SWIG_SetError(str) SWIG_Error(SWIG_RuntimeError, str)
+
+
+#define SWIG_PERL_DECL_ARGS_1(arg1) (SWIG_PERL_OBJECT_DECL arg1)
+#define SWIG_PERL_CALL_ARGS_1(arg1) (SWIG_PERL_OBJECT_CALL arg1)
+#define SWIG_PERL_DECL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_DECL arg1, arg2)
+#define SWIG_PERL_CALL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_CALL arg1, arg2)
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION 0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SWIG_OWNER SWIG_POINTER_OWN
+#define SWIG_SHADOW SWIG_OWNER << 1
+
+#define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
+
+/* SWIG Perl macros */
+
+/* Macro to call an XS function */
+#ifdef PERL_OBJECT
+# define SWIG_CALLXS(_name) _name(cv,pPerl)
+#else
+# ifndef MULTIPLICITY
+# define SWIG_CALLXS(_name) _name(cv)
+# else
+# define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
+# endif
+#endif
+
+/* Note: SwigMagicFuncHack is a typedef used to get the C++ compiler to just shut up already */
+
+#ifdef PERL_OBJECT
+#define MAGIC_PPERL CPerlObj *pPerl = (CPerlObj *) this;
+typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (CPerlObj::*SwigMagicFuncHack)(SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
+#define SWIGCLASS_STATIC
+#else
+#define MAGIC_PPERL
+#define SWIGCLASS_STATIC static SWIGUNUSED
+#ifndef MULTIPLICITY
+#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
+typedef int (*SwigMagicFunc)(SV *, MAGIC *);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (*SwigMagicFuncHack)(SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+
+#else
+#define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
+typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int (*SwigMagicFuncHack)(struct interpreter *, SV *, MAGIC *);
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif
+
+/* Workaround for bug in perl 5.6.x croak and earlier */
+#if (PERL_VERSION < 8)
+# ifdef PERL_OBJECT
+# define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
+static void SWIG_Perl_croak_null(CPerlObj *pPerl)
+# else
+static void SWIG_croak_null()
+# endif
+{
+ SV *err=ERRSV;
+# if (PERL_VERSION < 6)
+ croak("%_", err);
+# else
+ if (SvOK(err) && !SvROK(err)) croak("%_", err);
+ croak(Nullch);
+# endif
+}
+#else
+# define SWIG_croak_null() croak(Nullch)
+#endif
+
+
+/*
+ Define how strict is the cast between strings an integers/doubles
+ when overloading between these types occurs.
+
+ The default is making it as strict as possible by using SWIG_AddCast
+ when needed.
+
+ You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
+ disable the SWIG_AddCast, making the casting between string and
+ numbers less strict.
+
+ In the end, we try to solve the overloading between strings and
+ numerical types in the more natural way, but if you can avoid it,
+ well, avoid it using %rename, for example.
+*/
+#ifndef SWIG_PERL_NO_STRICT_STR2NUM
+# ifndef SWIG_PERL_STRICT_STR2NUM
+# define SWIG_PERL_STRICT_STR2NUM
+# endif
+#endif
+#ifdef SWIG_PERL_STRICT_STR2NUM
+/* string takes precedence */
+#define SWIG_Str2NumCast(x) SWIG_AddCast(x)
+#else
+/* number takes precedence */
+#define SWIG_Str2NumCast(x) x
+#endif
+
+
+
+#include <stdlib.h>
+
+SWIGRUNTIME const char *
+SWIG_Perl_TypeProxyName(const swig_type_info *type) {
+ if (!type) return NULL;
+ if (type->clientdata != NULL) {
+ return (const char*) type->clientdata;
+ }
+ else {
+ return type->name;
+ }
+}
+
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
+ SWIG_TypeCheck_Template(( (!iter->type->clientdata && (strcmp((char*)iter->type->name, c) == 0))
+ || (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0))), ty);
+}
+
+
+/* Function for getting a pointer value */
+
+SWIGRUNTIME int
+SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
+ swig_cast_info *tc;
+ void *voidptr = (void *)0;
+ SV *tsv = 0;
+ /* If magical, apply more magic */
+ if (SvGMAGICAL(sv))
+ mg_get(sv);
+
+ /* Check to see if this is an object */
+ if (sv_isobject(sv)) {
+ IV tmp = 0;
+ tsv = (SV*) SvRV(sv);
+ if ((SvTYPE(tsv) == SVt_PVHV)) {
+ MAGIC *mg;
+ if (SvMAGICAL(tsv)) {
+ mg = mg_find(tsv,'P');
+ if (mg) {
+ sv = mg->mg_obj;
+ if (sv_isobject(sv)) {
+ tsv = (SV*)SvRV(sv);
+ tmp = SvIV(tsv);
+ }
+ }
+ } else {
+ return SWIG_ERROR;
+ }
+ } else {
+ tmp = SvIV(tsv);
+ }
+ voidptr = INT2PTR(void *,tmp);
+ } else if (! SvOK(sv)) { /* Check for undef */
+ *(ptr) = (void *) 0;
+ return SWIG_OK;
+ } else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
+ if (!SvROK(sv)) {
+ *(ptr) = (void *) 0;
+ return SWIG_OK;
+ } else {
+ return SWIG_ERROR;
+ }
+ } else { /* Don't know what it is */
+ return SWIG_ERROR;
+ }
+ if (_t) {
+ /* Now see if the types match */
+ char *_c = HvNAME(SvSTASH(SvRV(sv)));
+ tc = SWIG_TypeProxyCheck(_c,_t);
+ if (!tc) {
+ return SWIG_ERROR;
+ }
+ *ptr = SWIG_TypeCast(tc,voidptr);
+ } else {
+ *ptr = voidptr;
+ }
+
+ /*
+ * DISOWN implementation: we need a perl guru to check this one.
+ */
+ if (tsv && (flags & SWIG_POINTER_DISOWN)) {
+ /*
+ * almost copy paste code from below SWIG_POINTER_OWN setting
+ */
+ SV *obj = sv;
+ HV *stash = SvSTASH(SvRV(obj));
+ GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
+ if (isGV(gv)) {
+ HV *hv = GvHVn(gv);
+ /*
+ * To set ownership (see below), a newSViv(1) entry is added.
+ * Hence, to remove ownership, we delete the entry.
+ */
+ if (hv_exists_ent(hv, obj, 0)) {
+ hv_delete_ent(hv, obj, 0, 0);
+ }
+ }
+ }
+ return SWIG_OK;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
+ if (ptr && (flags & SWIG_SHADOW)) {
+ SV *self;
+ SV *obj=newSV(0);
+ HV *hash=newHV();
+ HV *stash;
+ sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
+ stash=SvSTASH(SvRV(obj));
+ if (flags & SWIG_POINTER_OWN) {
+ HV *hv;
+ GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+ if (!isGV(gv))
+ gv_init(gv, stash, "OWNER", 5, FALSE);
+ hv=GvHVn(gv);
+ hv_store_ent(hv, obj, newSViv(1), 0);
+ }
+ sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
+ SvREFCNT_dec(obj);
+ self=newRV_noinc((SV *)hash);
+ sv_setsv(sv, self);
+ SvREFCNT_dec((SV *)self);
+ sv_bless(sv, stash);
+ }
+ else {
+ sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr);
+ }
+}
+
+SWIGRUNTIMEINLINE SV *
+SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
+ SV *result = sv_newmortal();
+ SWIG_MakePtr(result, ptr, t, flags);
+ return result;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
+ char result[1024];
+ char *r = result;
+ if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
+ *(r++) = '_';
+ r = SWIG_PackData(r,ptr,sz);
+ strcpy(r,SWIG_Perl_TypeProxyName(type));
+ sv_setpv(sv, result);
+}
+
+SWIGRUNTIME SV *
+SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
+ SV *result = sv_newmortal();
+ SWIG_Perl_MakePackedObj(result, ptr, sz, type);
+ return result;
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
+ swig_cast_info *tc;
+ const char *c = 0;
+
+ if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
+ c = SvPV(obj, PL_na);
+ /* Pointer values must start with leading underscore */
+ if (*c != '_') return SWIG_ERROR;
+ c++;
+ c = SWIG_UnpackData(c,ptr,sz);
+ if (ty) {
+ tc = SWIG_TypeCheck(c,ty);
+ if (!tc) return SWIG_ERROR;
+ }
+ return SWIG_OK;
+}
+
+
+/* Macros for low-level exception handling */
+#define SWIG_croak(x) { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
+
+
+typedef XS(SwigPerlWrapper);
+typedef SwigPerlWrapper *SwigPerlWrapperPtr;
+
+/* Structure for command table */
+typedef struct {
+ const char *name;
+ SwigPerlWrapperPtr wrapper;
+} swig_command_info;
+
+/* Information for constant table */
+
+#define SWIG_INT 1
+#define SWIG_FLOAT 2
+#define SWIG_STRING 3
+#define SWIG_POINTER 4
+#define SWIG_BINARY 5
+
+/* Constant information structure */
+typedef struct swig_constant_info {
+ int type;
+ const char *name;
+ long lvalue;
+ double dvalue;
+ void *pvalue;
+ swig_type_info **ptype;
+} swig_constant_info;
+
+
+/* Structure for variable table */
+typedef struct {
+ const char *name;
+ SwigMagicFunc set;
+ SwigMagicFunc get;
+ swig_type_info **type;
+} swig_variable_info;
+
+/* Magic variable code */
+#ifndef PERL_OBJECT
+#define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
+ #ifndef MULTIPLICITY
+ SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
+ #else
+ SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
+ #endif
+#else
+# define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
+SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
+#endif
+{
+ MAGIC *mg;
+ sv_magic(sv,sv,'U',(char *) name,strlen(name));
+ mg = mg_find(sv,'U');
+ mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
+ mg->mg_virtual->svt_get = (SwigMagicFuncHack) get;
+ mg->mg_virtual->svt_set = (SwigMagicFuncHack) set;
+ mg->mg_virtual->svt_len = 0;
+ mg->mg_virtual->svt_clear = 0;
+ mg->mg_virtual->svt_free = 0;
+}
+
+
+SWIGRUNTIME swig_module_info *
+SWIG_Perl_GetModule(void) {
+ static void *type_pointer = (void *)0;
+ SV *pointer;
+
+ /* first check if pointer already created */
+ if (!type_pointer) {
+ pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE);
+ if (pointer && SvOK(pointer)) {
+ type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
+ }
+ }
+
+ return (swig_module_info *) type_pointer;
+}
+
+SWIGRUNTIME void
+SWIG_Perl_SetModule(swig_module_info *module) {
+ SV *pointer;
+
+ /* create a new pointer */
+ pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE);
+ sv_setiv(pointer, PTR2IV(module));
+}
+
+#ifdef __cplusplus
+}
+#endif
+/* -----------------------------------------------------------------------------*
+ Standard SWIG API for use inside user code.
+
+ Don't include this file directly, run the command
+ swig -python -external-runtime
+ Also, read the Modules chapter of the SWIG Manual.
+
+ * -----------------------------------------------------------------------------*/
+
+#ifdef SWIG_MODULE_CLIENTDATA_TYPE
+
+SWIGRUNTIMEINLINE swig_type_info *
+SWIG_TypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata, const char *name) {
+ swig_module_info *module = SWIG_GetModule(clientdata);
+ return SWIG_TypeQueryModule(module, module, name);
+}
+
+SWIGRUNTIMEINLINE swig_type_info *
+SWIG_MangledTypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata, const char *name) {
+ swig_module_info *module = SWIG_GetModule(clientdata);
+ return SWIG_MangledTypeQueryModule(module, module, name);
+}
+
+#else
+
+SWIGRUNTIMEINLINE swig_type_info *
+SWIG_TypeQuery(const char *name) {
+ swig_module_info *module = SWIG_GetModule(NULL);
+ return SWIG_TypeQueryModule(module, module, name);
+}
+
+SWIGRUNTIMEINLINE swig_type_info *
+SWIG_MangledTypeQuery(const char *name) {
+ swig_module_info *module = SWIG_GetModule(NULL);
+ return SWIG_MangledTypeQueryModule(module, module, name);
+}
+
+#endif
--
GitLab