diff --git a/swig/perl/IO/IO.pm b/swig/perl/IO/IO.pm
new file mode 100644
index 0000000000000000000000000000000000000000..ae36874aa13748cffb72e73c9f3f30f431f6fde0
--- /dev/null
+++ b/swig/perl/IO/IO.pm
@@ -0,0 +1,445 @@
+ #
+ # 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::IO;
+use base qw(DynaLoader);
+require XML::Xerces;
+bootstrap XML::Xerces::IO;
+package XML::Xerces::IO;
+package XML::Xerces::IO;
+
+# ------- FUNCTION WRAPPERS --------
+
+package XML::Xerces;
+
+
+############# Class : XML::Xerces::InputSource ##############
+
+package XML::Xerces::InputSource;
+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_InputSource($self);
+ delete $OWNER{$self};
+ }
+}
+
+*makeStream = *XML::Xercesc::InputSource_makeStream;
+*getEncoding = *XML::Xercesc::InputSource_getEncoding;
+*getPublicId = *XML::Xercesc::InputSource_getPublicId;
+*getSystemId = *XML::Xercesc::InputSource_getSystemId;
+*getIssueFatalErrorIfNotFound = *XML::Xercesc::InputSource_getIssueFatalErrorIfNotFound;
+*getMemoryManager = *XML::Xercesc::InputSource_getMemoryManager;
+*setEncoding = *XML::Xercesc::InputSource_setEncoding;
+*setPublicId = *XML::Xercesc::InputSource_setPublicId;
+*setSystemId = *XML::Xercesc::InputSource_setSystemId;
+*setIssueFatalErrorIfNotFound = *XML::Xercesc::InputSource_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::LocalFileInputSource ##############
+
+package XML::Xerces::LocalFileInputSource;
+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_LocalFileInputSource(@_);
+ 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_LocalFileInputSource($self);
+ delete $OWNER{$self};
+ }
+}
+
+*makeStream = *XML::Xercesc::LocalFileInputSource_makeStream;
+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::StdInInputSource ##############
+
+package XML::Xerces::StdInInputSource;
+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_StdInInputSource(@_);
+ 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_StdInInputSource($self);
+ delete $OWNER{$self};
+ }
+}
+
+*makeStream = *XML::Xercesc::StdInInputSource_makeStream;
+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::URLInputSource ##############
+
+package XML::Xerces::URLInputSource;
+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_URLInputSource(@_);
+ 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_URLInputSource($self);
+ delete $OWNER{$self};
+ }
+}
+
+*makeStream = *XML::Xercesc::URLInputSource_makeStream;
+*urlSrc = *XML::Xercesc::URLInputSource_urlSrc;
+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::MemBufInputSource ##############
+
+package XML::Xerces::MemBufInputSource;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::InputSource XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ # SYSTEM ID is *optional*
+ if (scalar @_ == 1) {
+ push(@_,'FAKE_SYSTEM_ID');
+ }
+
+ my $self = XML::Xercesc::new_MemBufInputSource(@_);
+
+ 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_MemBufInputSource($self);
+ delete $OWNER{$self};
+ }
+}
+
+*makeStream = *XML::Xercesc::MemBufInputSource_makeStream;
+*setCopyBufToStream = *XML::Xercesc::MemBufInputSource_setCopyBufToStream;
+*resetMemBufInputSource = *XML::Xercesc::MemBufInputSource_resetMemBufInputSource;
+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::XMLFormatter ##############
+
+package XML::Xerces::XMLFormatter;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+*NoEscapes = *XML::Xercesc::XMLFormatter_NoEscapes;
+*StdEscapes = *XML::Xercesc::XMLFormatter_StdEscapes;
+*AttrEscapes = *XML::Xercesc::XMLFormatter_AttrEscapes;
+*CharEscapes = *XML::Xercesc::XMLFormatter_CharEscapes;
+*EscapeFlags_Count = *XML::Xercesc::XMLFormatter_EscapeFlags_Count;
+*DefaultEscape = *XML::Xercesc::XMLFormatter_DefaultEscape;
+*UnRep_Fail = *XML::Xercesc::XMLFormatter_UnRep_Fail;
+*UnRep_CharRef = *XML::Xercesc::XMLFormatter_UnRep_CharRef;
+*UnRep_Replace = *XML::Xercesc::XMLFormatter_UnRep_Replace;
+*DefaultUnRep = *XML::Xercesc::XMLFormatter_DefaultUnRep;
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_XMLFormatter(@_);
+ 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_XMLFormatter($self);
+ delete $OWNER{$self};
+ }
+}
+
+*formatBuf = *XML::Xercesc::XMLFormatter_formatBuf;
+*writeBOM = *XML::Xercesc::XMLFormatter_writeBOM;
+*getEncodingName = *XML::Xercesc::XMLFormatter_getEncodingName;
+*getTranscoder = *XML::Xercesc::XMLFormatter_getTranscoder;
+*setEscapeFlags = *XML::Xercesc::XMLFormatter_setEscapeFlags;
+*setUnRepFlags = *XML::Xercesc::XMLFormatter_setUnRepFlags;
+*__lshift__ = *XML::Xercesc::XMLFormatter___lshift__;
+*getEscapeFlags = *XML::Xercesc::XMLFormatter_getEscapeFlags;
+*getUnRepFlags = *XML::Xercesc::XMLFormatter_getUnRepFlags;
+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::XMLFormatTarget ##############
+
+package XML::Xerces::XMLFormatTarget;
+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_XMLFormatTarget($self);
+ delete $OWNER{$self};
+ }
+}
+
+*writeChars = *XML::Xercesc::XMLFormatTarget_writeChars;
+*flush = *XML::Xercesc::XMLFormatTarget_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::StdOutFormatTarget ##############
+
+package XML::Xerces::StdOutFormatTarget;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::XMLFormatTarget 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::XMLFormatTarget 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::XMLFormatTarget 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;
+}
+
+
+# ------- VARIABLE STUBS --------
+
+package XML::Xerces;
+
+1;
diff --git a/swig/perl/IO/Makefile.PL b/swig/perl/IO/Makefile.PL
new file mode 100644
index 0000000000000000000000000000000000000000..ba308b00efc267e970404925b768eae8bb0be756
--- /dev/null
+++ b/swig/perl/IO/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_IO_postamble {
+ my $retval = <<TERMINUS;
+IO-tmp.pm: $SCRIPTS_DIR/postModule.pl $INTERFACE_DIR/Perl/dom-shadow.i
+ \$(SWIG) $SWIG_ARGS -o Xerces_IO-tmp.cpp -pm IO-tmp.pm $INTERFACE_DIR/Xerces_IO.i
+
+IO.pm: $SCRIPTS_DIR/postModule.pl IO-tmp.pm
+ perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postModule.pl --in=IO-tmp.pm --out=IO.pm
+
+Xerces_IO.cpp: $SCRIPTS_DIR/postSource.pl Xerces_IO-tmp.cpp
+ perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postSource.pl --in=Xerces_IO-tmp.cpp --out=Xerces_IO.cpp
+
+Xerces_IO-tmp.cpp: $INTERFACE_DIR/Xerces_IO.i @IO_INTERFACE_FILES
+ \$(SWIG) $SWIG_ARGS -o Xerces_IO-tmp.cpp -pm IO-tmp.pm $INTERFACE_DIR/Xerces_IO.i
+ perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postModule.pl --in=IO-tmp.pm --out=IO.pm
+ mkdir -p $BLIB_DIR
+ cp -f IO.pm $BLIB_DIR/IO.pm
+
+TERMINUS
+ return $retval;
+ }
+
+ *MY::postamble = \&Xerces_IO_postamble;
+}
+
+WriteMakefile(
+ 'NAME' => 'XML::Xerces::IO',
+ 'INC' => $INCLUDES,
+ 'LIBS' => [$LIBS],
+ 'MYEXTLIB' => "$TRANSCODER_LIB $HANDLER_LIB",
+ 'OBJECT' => 'Xerces_IO$(OBJ_EXT)',
+ 'CCFLAGS' => $CFLAGS,
+ 'CC' => $CXX,
+ 'SKIP' => [qw( test makeaperl xs_o)],
+ @OPTIMIZE,
+ @LDFLAGS,
+);
+
diff --git a/swig/perl/IO/Xerces_IO.cpp b/swig/perl/IO/Xerces_IO.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..30bbe81ea9459cea26862e74fe43d4825ed69962
--- /dev/null
+++ b/swig/perl/IO/Xerces_IO.cpp
@@ -0,0 +1,6654 @@
+/*
+ * 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_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t swig_types[0]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t swig_types[1]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_t swig_types[2]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__BinInputStream swig_types[3]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDAttDef swig_types[4]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDAttDefList swig_types[5]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDElementDecl swig_types[6]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDEntityDecl swig_types[7]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDGrammar swig_types[8]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDValidator swig_types[9]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar swig_types[10]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource swig_types[11]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget swig_types[12]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileInputSource swig_types[13]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget swig_types[14]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufInputSource swig_types[15]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager swig_types[16]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[17]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[18]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[19]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[20]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIAttribute swig_types[21]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIAttributeList swig_types[22]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIElement swig_types[23]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIItem swig_types[24]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__QName swig_types[25]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t swig_types[26]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[27]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[28]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t swig_types[29]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException swig_types[30]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException swig_types[31]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException swig_types[32]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException swig_types[33]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaAttDef swig_types[34]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaAttDefList swig_types[35]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaElementDecl swig_types[36]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaGrammar swig_types[37]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaValidator swig_types[38]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdInInputSource swig_types[39]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget swig_types[40]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource swig_types[41]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttDef swig_types[42]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttDefList swig_types[43]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttr swig_types[44]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLContentModel swig_types[45]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDTDDescription swig_types[46]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLElementDecl swig_types[47]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityDecl swig_types[48]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLException swig_types[49]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget swig_types[50]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter swig_types[51]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription swig_types[52]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLNotationDecl swig_types[53]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken swig_types[54]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLSchemaDescription swig_types[55]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLTranscoder swig_types[56]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLURL swig_types[57]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLUri swig_types[58]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator swig_types[59]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMemory swig_types[60]
+#define SWIGTYPE_p_char swig_types[61]
+#define SWIGTYPE_p_int32_t swig_types[62]
+#define SWIGTYPE_p_size_t swig_types[63]
+#define SWIGTYPE_p_ssize_t swig_types[64]
+#define SWIGTYPE_p_uint16_t swig_types[65]
+#define SWIGTYPE_p_uint32_t swig_types[66]
+#define SWIGTYPE_p_unsigned_char swig_types[67]
+static swig_type_info *swig_types[69];
+static swig_module_info swig_module = {swig_types, 68, 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__IO
+
+#define SWIG_name "XML::Xercesc::boot_XML__Xerces__IO"
+#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/framework/LocalFileInputSource.hpp"
+#include "xercesc/framework/MemBufInputSource.hpp"
+#include "xercesc/framework/StdInInputSource.hpp"
+#include "xercesc/framework/URLInputSource.hpp"
+
+#include "xercesc/framework/XMLFormatter.hpp"
+#include "xercesc/framework/MemBufFormatTarget.hpp"
+#include "xercesc/framework/LocalFileFormatTarget.hpp"
+#include "xercesc/framework/StdOutFormatTarget.hpp"
+
+
+
+
+XERCES_CPP_NAMESPACE_USE
+
+
+
+#include "xercesc/sax/SAXException.hpp"
+#include "xercesc/sax/SAXParseException.hpp"
+#include "xercesc/sax/EntityResolver.hpp"
+
+#include "xercesc/util/PlatformUtils.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/util/NameIdPool.hpp"
+#include "xercesc/util/XMLEnumerator.hpp"
+#include "xercesc/util/SecurityManager.hpp"
+#include "xercesc/util/XMLException.hpp"
+#include "xercesc/util/XMLEntityResolver.hpp"
+
+#include "xercesc/framework/XMLValidator.hpp"
+#include "xercesc/framework/XMLDocumentHandler.hpp"
+#include "xercesc/framework/XMLPScanToken.hpp"
+
+#include "xercesc/framework/psvi/PSVIHandler.hpp"
+#include "xercesc/framework/psvi/PSVIItem.hpp"
+#include "xercesc/framework/psvi/PSVIElement.hpp"
+#include "xercesc/framework/psvi/PSVIAttribute.hpp"
+#include "xercesc/framework/psvi/PSVIAttributeList.hpp"
+
+#include "xercesc/framework/XMLGrammarDescription.hpp"
+#include "xercesc/framework/XMLDTDDescription.hpp"
+#include "xercesc/framework/XMLSchemaDescription.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 "PSVIWriter/PSVIUni.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);
+ }
+}
+
+
+
+
+
+
+#include "Transcoder.hpp"
+#include "XMLExceptionHandler.hpp"
+
+#include "PerlCallbackHandler.hpp"
+#include "PerlErrorCallbackHandler.hpp"
+#include "PerlDOMCallbackHandler.hpp"
+#include "PerlEntityResolverHandler.hpp"
+
+
+
+
+// we initialize the static UTF-8 transcoding info
+// these are used by the typemaps to convert between
+// Xerces internal UTF-16 and the scripting language format
+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);
+}
+
+/*
+ * The generic 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_XML_EXCEPTION \
+ catch (const XMLException& e) \
+ { \
+ makeXMLException(e); \
+ goto fail; \
+ } \
+ catch (...) \
+ { \
+ SWIG_croak("Handling Unknown exception"); \
+ goto fail; \
+ }
+
+
+
+static swig_type_info *
+Grammar_dynamic_cast(void **ptr) {
+ Grammar **nptr = (Grammar **) ptr;
+ if (*nptr == NULL) {
+ return NULL;
+ }
+ short int type = (*nptr)->getGrammarType();
+ if (type == Grammar::DTDGrammarType) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDGrammar;
+ }
+ if (type == Grammar::SchemaGrammarType) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaGrammar;
+ }
+ return NULL;
+}
+
+
+static swig_type_info *
+XMLGrammarDescription_dynamic_cast(void **ptr) {
+ XMLGrammarDescription **nptr = (XMLGrammarDescription **) ptr;
+ if (*nptr == NULL) {
+ return NULL;
+ }
+ short int type = (*nptr)->getGrammarType();
+ if (type == Grammar::DTDGrammarType) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDTDDescription;
+ }
+ if (type == Grammar::SchemaGrammarType) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLSchemaDescription;
+ }
+ return NULL;
+}
+
+
+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 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_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;
+}
+
+
+#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_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;
+}
+
+
+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_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_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_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_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));
+}
+
+
+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_unsigned_SS_int SWIG_PERL_DECL_ARGS_1(unsigned int value)
+{
+ return SWIG_From_unsigned_SS_long SWIG_PERL_CALL_ARGS_1(value);
+}
+
+#ifdef PERL_OBJECT
+#define MAGIC_CLASS _wrap_XML__Xerces__IO_var::
+class _wrap_XML__Xerces__IO_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_delete_InputSource) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_InputSource(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_InputSource_makeStream) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) 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: InputSource_makeStream(self);");
+ }
+ 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 '" "InputSource_makeStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::BinInputStream *)((XERCES_CPP_NAMESPACE::InputSource const *)arg1)->makeStream();
+ }
+ CATCH_XML_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_InputSource_getEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: InputSource_getEncoding(self);");
+ }
+ 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 '" "InputSource_getEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::InputSource const *)arg1)->getEncoding();
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_InputSource_getPublicId) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: InputSource_getPublicId(self);");
+ }
+ 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 '" "InputSource_getPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::InputSource const *)arg1)->getPublicId();
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_InputSource_getSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: InputSource_getSystemId(self);");
+ }
+ 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 '" "InputSource_getSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::InputSource const *)arg1)->getSystemId();
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_InputSource_getIssueFatalErrorIfNotFound) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: InputSource_getIssueFatalErrorIfNotFound(self);");
+ }
+ 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 '" "InputSource_getIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::InputSource const *)arg1)->getIssueFatalErrorIfNotFound();
+ }
+ 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_InputSource_getMemoryManager) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
+ XERCES_CPP_NAMESPACE::MemoryManager *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: InputSource_getMemoryManager(self);");
+ }
+ 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 '" "InputSource_getMemoryManager" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::MemoryManager *)((XERCES_CPP_NAMESPACE::InputSource const *)arg1)->getMemoryManager();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_InputSource_setEncoding) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: InputSource_setEncoding(self,encodingStr);");
+ }
+ 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 '" "InputSource_setEncoding" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->setEncoding((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_InputSource_setPublicId) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: InputSource_setPublicId(self,publicId);");
+ }
+ 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 '" "InputSource_setPublicId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->setPublicId((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_InputSource_setSystemId) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: InputSource_setSystemId(self,systemId);");
+ }
+ 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 '" "InputSource_setSystemId" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->setSystemId((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_InputSource_setIssueFatalErrorIfNotFound) {
+ {
+ XERCES_CPP_NAMESPACE::InputSource *arg1 = (XERCES_CPP_NAMESPACE::InputSource *) 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: InputSource_setIssueFatalErrorIfNotFound(self,flag);");
+ }
+ 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 '" "InputSource_setIssueFatalErrorIfNotFound" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::InputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::InputSource * >(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 '" "InputSource_setIssueFatalErrorIfNotFound" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setIssueFatalErrorIfNotFound(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_LocalFileInputSource__SWIG_0) {
+ {
+ XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::LocalFileInputSource *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: new_LocalFileInputSource(basePath,relativePath);");
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg1 = UTF8_TRANSCODER->Local2XMLString(ST(0));
+
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::LocalFileInputSource *)new XERCES_CPP_NAMESPACE::LocalFileInputSource((XMLCh const *)arg1,(XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileInputSource, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_LocalFileInputSource__SWIG_1) {
+ {
+ XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::LocalFileInputSource *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_LocalFileInputSource(filePath);");
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg1 = UTF8_TRANSCODER->Local2XMLString(ST(0));
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::LocalFileInputSource *)new XERCES_CPP_NAMESPACE::LocalFileInputSource((XMLCh const *)arg1);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileInputSource, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_LocalFileInputSource) {
+ 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;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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_LocalFileInputSource__SWIG_1); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_LocalFileInputSource__SWIG_0); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_LocalFileInputSource'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_LocalFileInputSource) {
+ {
+ XERCES_CPP_NAMESPACE::LocalFileInputSource *arg1 = (XERCES_CPP_NAMESPACE::LocalFileInputSource *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_LocalFileInputSource(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileInputSource, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalFileInputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LocalFileInputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LocalFileInputSource * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_LocalFileInputSource_makeStream) {
+ {
+ XERCES_CPP_NAMESPACE::LocalFileInputSource *arg1 = (XERCES_CPP_NAMESPACE::LocalFileInputSource *) 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: LocalFileInputSource_makeStream(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileInputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalFileInputSource_makeStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::LocalFileInputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::LocalFileInputSource * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::BinInputStream *)((XERCES_CPP_NAMESPACE::LocalFileInputSource const *)arg1)->makeStream();
+ }
+ CATCH_XML_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_new_StdInInputSource) {
+ {
+ XERCES_CPP_NAMESPACE::StdInInputSource *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_StdInInputSource();");
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::StdInInputSource *)new XERCES_CPP_NAMESPACE::StdInInputSource();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdInInputSource, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_StdInInputSource) {
+ {
+ XERCES_CPP_NAMESPACE::StdInInputSource *arg1 = (XERCES_CPP_NAMESPACE::StdInInputSource *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_StdInInputSource(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdInInputSource, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StdInInputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::StdInInputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::StdInInputSource * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_StdInInputSource_makeStream) {
+ {
+ XERCES_CPP_NAMESPACE::StdInInputSource *arg1 = (XERCES_CPP_NAMESPACE::StdInInputSource *) 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: StdInInputSource_makeStream(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdInInputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdInInputSource_makeStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::StdInInputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::StdInInputSource * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::BinInputStream *)((XERCES_CPP_NAMESPACE::StdInInputSource const *)arg1)->makeStream();
+ }
+ CATCH_XML_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_new_URLInputSource__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::XMLURL *arg1 = 0 ;
+ XERCES_CPP_NAMESPACE::URLInputSource *result = 0 ;
+ void *argp1 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_URLInputSource(urlId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLURL, 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_URLInputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLURL const &""'");
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_URLInputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLURL const &""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLURL * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::URLInputSource *)new XERCES_CPP_NAMESPACE::URLInputSource((XERCES_CPP_NAMESPACE::XMLURL const &)*arg1);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_URLInputSource__SWIG_1) {
+ {
+ XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::URLInputSource *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: new_URLInputSource(baseId,systemId);");
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg1 = UTF8_TRANSCODER->Local2XMLString(ST(0));
+
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::URLInputSource *)new XERCES_CPP_NAMESPACE::URLInputSource((XMLCh const *)arg1,(XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_URLInputSource__SWIG_2) {
+ {
+ XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::URLInputSource *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: new_URLInputSource(baseId,systemId,publicId);");
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg1 = UTF8_TRANSCODER->Local2XMLString(ST(0));
+
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::URLInputSource *)new XERCES_CPP_NAMESPACE::URLInputSource((XMLCh const *)arg1,(XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_URLInputSource) {
+ 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__XMLURL, 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;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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_URLInputSource__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_URLInputSource__SWIG_1); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_URLInputSource__SWIG_2); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_URLInputSource'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_URLInputSource) {
+ {
+ XERCES_CPP_NAMESPACE::URLInputSource *arg1 = (XERCES_CPP_NAMESPACE::URLInputSource *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_URLInputSource(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_URLInputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::URLInputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::URLInputSource * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_URLInputSource_makeStream) {
+ {
+ XERCES_CPP_NAMESPACE::URLInputSource *arg1 = (XERCES_CPP_NAMESPACE::URLInputSource *) 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: URLInputSource_makeStream(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLInputSource_makeStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::URLInputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::URLInputSource * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::BinInputStream *)((XERCES_CPP_NAMESPACE::URLInputSource const *)arg1)->makeStream();
+ }
+ CATCH_XML_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_URLInputSource_urlSrc) {
+ {
+ XERCES_CPP_NAMESPACE::URLInputSource *arg1 = (XERCES_CPP_NAMESPACE::URLInputSource *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLURL *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: URLInputSource_urlSrc(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLInputSource_urlSrc" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::URLInputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::URLInputSource * >(argp1);
+ {
+ try
+ {
+ {
+ XERCES_CPP_NAMESPACE::XMLURL const &_result_ref = ((XERCES_CPP_NAMESPACE::URLInputSource const *)arg1)->urlSrc();
+ result = (XERCES_CPP_NAMESPACE::XMLURL *) &_result_ref;
+ }
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLURL, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_MemBufInputSource) {
+ {
+ XMLByte *arg1 = (XMLByte *) (XMLByte *)0 ;
+ unsigned int arg2 ;
+ XMLCh *arg3 = (XMLCh *) (XMLCh *)0 ;
+ bool arg4 ;
+ XERCES_CPP_NAMESPACE::MemBufInputSource *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ arg4 = true;
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: new_MemBufInputSource(srcDocBytes,byteCount,bufId);");
+ }
+ {
+ if (SvPOK(ST(0))||SvIOK(ST(0))||SvNOK(ST(0))) {
+ STRLEN len;
+ XMLByte *xmlbytes = (XMLByte *)SvPV(ST(0), len);
+ arg2 = len;
+ arg1 = new XMLByte[len];
+ memcpy(arg1, xmlbytes, len);
+ } else {
+ SWIG_croak("Type error in argument 2 of new_MemBufInputSource, Expected perl-string.");
+ }
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::MemBufInputSource *)new XERCES_CPP_NAMESPACE::MemBufInputSource((XMLByte const *)arg1,arg2,(XMLCh const *)arg3,arg4);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufInputSource, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg3;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg3;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_MemBufInputSource) {
+ {
+ XERCES_CPP_NAMESPACE::MemBufInputSource *arg1 = (XERCES_CPP_NAMESPACE::MemBufInputSource *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_MemBufInputSource(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufInputSource, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MemBufInputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufInputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufInputSource * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_MemBufInputSource_makeStream) {
+ {
+ XERCES_CPP_NAMESPACE::MemBufInputSource *arg1 = (XERCES_CPP_NAMESPACE::MemBufInputSource *) 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: MemBufInputSource_makeStream(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufInputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemBufInputSource_makeStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufInputSource const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufInputSource * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::BinInputStream *)((XERCES_CPP_NAMESPACE::MemBufInputSource const *)arg1)->makeStream();
+ }
+ CATCH_XML_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_MemBufInputSource_setCopyBufToStream) {
+ {
+ XERCES_CPP_NAMESPACE::MemBufInputSource *arg1 = (XERCES_CPP_NAMESPACE::MemBufInputSource *) 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: MemBufInputSource_setCopyBufToStream(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufInputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemBufInputSource_setCopyBufToStream" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufInputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufInputSource * >(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 '" "MemBufInputSource_setCopyBufToStream" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setCopyBufToStream(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_MemBufInputSource_resetMemBufInputSource) {
+ {
+ XERCES_CPP_NAMESPACE::MemBufInputSource *arg1 = (XERCES_CPP_NAMESPACE::MemBufInputSource *) 0 ;
+ XMLByte *arg2 = (XMLByte *) (XMLByte *)0 ;
+ unsigned int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: MemBufInputSource_resetMemBufInputSource(self,srcDocBytes,byteCount);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufInputSource, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemBufInputSource_resetMemBufInputSource" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemBufInputSource *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemBufInputSource * >(argp1);
+ {
+ if (SvPOK(ST(1))||SvIOK(ST(1))||SvNOK(ST(1))) {
+ STRLEN len;
+ XMLByte *xmlbytes = (XMLByte *)SvPV(ST(1), len);
+ arg3 = len;
+ arg2 = new XMLByte[len];
+ memcpy(arg2, xmlbytes, len);
+ } else {
+ SWIG_croak("Type error in argument 2 of MemBufInputSource_resetMemBufInputSource, Expected perl-string.");
+ }
+ }
+ {
+ try
+ {
+ (arg1)->resetMemBufInputSource((XMLByte const *)arg2,arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_XMLFormatter__SWIG_0) {
+ {
+ XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatTarget *arg3 = (XERCES_CPP_NAMESPACE::XMLFormatTarget *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags arg4 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags arg5 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *result = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: new_XMLFormatter(outEncoding,docVersion,target,escapeFlags,unrepFlags);");
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg1 = UTF8_TRANSCODER->Local2XMLString(ST(0));
+
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XMLFormatter" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatTarget *const""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatTarget * >(argp3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLFormatter" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags""'");
+ }
+ arg4 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags >(val4);
+ ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_XMLFormatter" "', argument " "5"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags""'");
+ }
+ arg5 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags >(val5);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter *)new XERCES_CPP_NAMESPACE::XMLFormatter((XMLCh const *)arg1,(XMLCh const *)arg2,arg3,arg4,arg5);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_XMLFormatter__SWIG_1) {
+ {
+ XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatTarget *arg3 = (XERCES_CPP_NAMESPACE::XMLFormatTarget *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags arg4 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *result = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: new_XMLFormatter(outEncoding,docVersion,target,escapeFlags);");
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg1 = UTF8_TRANSCODER->Local2XMLString(ST(0));
+
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XMLFormatter" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatTarget *const""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatTarget * >(argp3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLFormatter" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags""'");
+ }
+ arg4 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags >(val4);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter *)new XERCES_CPP_NAMESPACE::XMLFormatter((XMLCh const *)arg1,(XMLCh const *)arg2,arg3,arg4);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_XMLFormatter__SWIG_2) {
+ {
+ XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatTarget *arg3 = (XERCES_CPP_NAMESPACE::XMLFormatTarget *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *result = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: new_XMLFormatter(outEncoding,docVersion,target);");
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg1 = UTF8_TRANSCODER->Local2XMLString(ST(0));
+
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XMLFormatter" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatTarget *const""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatTarget * >(argp3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter *)new XERCES_CPP_NAMESPACE::XMLFormatter((XMLCh const *)arg1,(XMLCh const *)arg2,arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_XMLFormatter__SWIG_3) {
+ {
+ XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatTarget *arg2 = (XERCES_CPP_NAMESPACE::XMLFormatTarget *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags arg3 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags arg4 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *result = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: new_XMLFormatter(outEncoding,target,escapeFlags,unrepFlags);");
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg1 = UTF8_TRANSCODER->Local2XMLString(ST(0));
+
+ 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 '" "new_XMLFormatter" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatTarget *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatTarget * >(argp2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLFormatter" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags""'");
+ }
+ arg3 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags >(val3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_XMLFormatter" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags""'");
+ }
+ arg4 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags >(val4);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter *)new XERCES_CPP_NAMESPACE::XMLFormatter((XMLCh const *)arg1,arg2,arg3,arg4);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_XMLFormatter__SWIG_4) {
+ {
+ XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatTarget *arg2 = (XERCES_CPP_NAMESPACE::XMLFormatTarget *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags arg3 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *result = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: new_XMLFormatter(outEncoding,target,escapeFlags);");
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg1 = UTF8_TRANSCODER->Local2XMLString(ST(0));
+
+ 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 '" "new_XMLFormatter" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatTarget *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatTarget * >(argp2);
+ ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_XMLFormatter" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags""'");
+ }
+ arg3 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags >(val3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter *)new XERCES_CPP_NAMESPACE::XMLFormatter((XMLCh const *)arg1,arg2,arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_XMLFormatter__SWIG_5) {
+ {
+ XMLCh *arg1 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatTarget *arg2 = (XERCES_CPP_NAMESPACE::XMLFormatTarget *) (XERCES_CPP_NAMESPACE::XMLFormatTarget *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *result = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: new_XMLFormatter(outEncoding,target);");
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg1 = UTF8_TRANSCODER->Local2XMLString(ST(0));
+
+ 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 '" "new_XMLFormatter" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatTarget *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatTarget * >(argp2);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter *)new XERCES_CPP_NAMESPACE::XMLFormatter((XMLCh const *)arg1,arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ delete[] arg1;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ delete[] arg1;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_XMLFormatter) {
+ 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;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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__XMLFormatTarget, 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;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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__XMLFormatTarget, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_int 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 == 3) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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__XMLFormatTarget, 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:
+
+ if (items == 4) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_int 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_int 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:
+
+ if (items == 4) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_5;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_5;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_5;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_5;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 5;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_5:
+
+ if (items == 5) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_6;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_6;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(2), &vptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_6;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_6;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), NULL);
+ _v = SWIG_CheckState(res);
+ }
+ }
+ if (!_v) goto check_6;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 6;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_6:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XMLFormatter__SWIG_5); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XMLFormatter__SWIG_4); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XMLFormatter__SWIG_2); return;
+ case 4:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XMLFormatter__SWIG_3); return;
+ case 5:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XMLFormatter__SWIG_1); return;
+ case 6:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_XMLFormatter__SWIG_0); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_XMLFormatter'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_XMLFormatter) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_XMLFormatter(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLFormatter" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter_formatBuf__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ unsigned int arg3 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags arg4 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 5) || (items > 5)) {
+ SWIG_croak("Usage: XMLFormatter_formatBuf(self,toFormat,count,escapeFlags,unrepFlags);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter_formatBuf" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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 '" "XMLFormatter_formatBuf" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLFormatter_formatBuf" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags""'");
+ }
+ arg4 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags >(val4);
+ ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XMLFormatter_formatBuf" "', argument " "5"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags""'");
+ }
+ arg5 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags >(val5);
+ {
+ try
+ {
+ (arg1)->formatBuf((XMLCh const *)arg2,arg3,arg4,arg5);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter_formatBuf__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ unsigned int arg3 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 4) || (items > 4)) {
+ SWIG_croak("Usage: XMLFormatter_formatBuf(self,toFormat,count,escapeFlags);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter_formatBuf" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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 '" "XMLFormatter_formatBuf" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
+ ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XMLFormatter_formatBuf" "', argument " "4"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags""'");
+ }
+ arg4 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags >(val4);
+ {
+ try
+ {
+ (arg1)->formatBuf((XMLCh const *)arg2,arg3,arg4);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter_formatBuf__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 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: XMLFormatter_formatBuf(self,toFormat,count);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter_formatBuf" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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 '" "XMLFormatter_formatBuf" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
+ {
+ try
+ {
+ (arg1)->formatBuf((XMLCh const *)arg2,arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter_formatBuf) {
+ 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__XMLFormatter, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_1;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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(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 == 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__XMLFormatter, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_unsigned_SS_int 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;
+ {
+ {
+ int res = SWIG_AsVal_int 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;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 2;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_2:
+
+ 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__XMLFormatter, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_unsigned_SS_int 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_int 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;
+ {
+ {
+ int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), 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:
+
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XMLFormatter_formatBuf__SWIG_2); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XMLFormatter_formatBuf__SWIG_1); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XMLFormatter_formatBuf__SWIG_0); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'XMLFormatter_formatBuf'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_XMLFormatter___lshift____SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XMLFormatter___lshift__(self,toFormat);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter___lshift__" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter &_result_ref = (arg1)->operator <<((XMLCh const *)arg2);
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter *) &_result_ref;
+ }
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter___lshift____SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XMLCh arg2 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XMLFormatter___lshift__(self,toFormat);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter___lshift__" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp1);
+ {
+ res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_uint16_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLFormatter___lshift__" "', argument " "2"" of type '" "XMLCh const""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLFormatter___lshift__" "', argument " "2"" of type '" "XMLCh const""'");
+ } else {
+ arg2 = *(reinterpret_cast< XMLCh * >(argp2));
+ }
+ }
+ {
+ try
+ {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter &_result_ref = (arg1)->operator <<(arg2);
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter *) &_result_ref;
+ }
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter_writeBOM) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XMLByte *arg2 = (XMLByte *) (XMLByte *)0 ;
+ unsigned int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ unsigned int val3 ;
+ int ecode3 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: XMLFormatter_writeBOM(self,toFormat,count);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter_writeBOM" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(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 '" "XMLFormatter_writeBOM" "', 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 '" "XMLFormatter_writeBOM" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
+ {
+ try
+ {
+ (arg1)->writeBOM((XMLByte const *)arg2,arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter_getEncodingName) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XMLFormatter_getEncodingName(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter_getEncodingName" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::XMLFormatter const *)arg1)->getEncodingName();
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter_getTranscoder) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLTranscoder *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XMLFormatter_getTranscoder(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter_getTranscoder" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLTranscoder *)((XERCES_CPP_NAMESPACE::XMLFormatter const *)arg1)->getTranscoder();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLTranscoder, 0 | 0); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter_setEscapeFlags) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XMLFormatter_setEscapeFlags(self,newFlags);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter_setEscapeFlags" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(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 '" "XMLFormatter_setEscapeFlags" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags >(val2);
+ {
+ try
+ {
+ (arg1)->setEscapeFlags(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter_setUnRepFlags) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: XMLFormatter_setUnRepFlags(self,newFlags);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter_setUnRepFlags" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(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 '" "XMLFormatter_setUnRepFlags" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags >(val2);
+ {
+ try
+ {
+ (arg1)->setUnRepFlags(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter___lshift____SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags arg2 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *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: XMLFormatter___lshift__(self,newFlags);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter___lshift__" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(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 '" "XMLFormatter___lshift__" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags >(val2);
+ {
+ try
+ {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter &_result_ref = (arg1)->operator <<(arg2);
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter *) &_result_ref;
+ }
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter___lshift____SWIG_3) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags arg2 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter *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: XMLFormatter___lshift__(self,newFlags);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter___lshift__" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(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 '" "XMLFormatter___lshift__" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags >(val2);
+ {
+ try
+ {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter &_result_ref = (arg1)->operator <<(arg2);
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter *) &_result_ref;
+ }
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter___lshift__) {
+ 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__XMLFormatter, 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_uint16_t, 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__XMLFormatter, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_int 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 == 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__XMLFormatter, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ int res = SWIG_AsVal_int 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;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ check_3:
+
+ 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__XMLFormatter, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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_XMLFormatter___lshift____SWIG_1); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XMLFormatter___lshift____SWIG_2); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XMLFormatter___lshift____SWIG_3); return;
+ case 4:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XMLFormatter___lshift____SWIG_0); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'XMLFormatter___lshift__'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_XMLFormatter_getEscapeFlags) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XMLFormatter_getEscapeFlags(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter_getEscapeFlags" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags)((XERCES_CPP_NAMESPACE::XMLFormatter const *)arg1)->getEscapeFlags();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatter_getUnRepFlags) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatter *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatter *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XMLFormatter_getUnRepFlags(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatter_getUnRepFlags" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatter const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatter * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLFormatter::UnRepFlags)((XERCES_CPP_NAMESPACE::XMLFormatter const *)arg1)->getUnRepFlags();
+ }
+ CATCH_XML_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_XMLFormatTarget) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatTarget *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_XMLFormatTarget(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLFormatTarget" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatTarget * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatTarget_writeChars) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatTarget *) 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: XMLFormatTarget_writeChars(self,toWrite,count,formatter);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatTarget_writeChars" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatTarget * >(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 '" "XMLFormatTarget_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 '" "XMLFormatTarget_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 '" "XMLFormatTarget_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_XML_EXCEPTION
+ }
+
+
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLFormatTarget_flush) {
+ {
+ XERCES_CPP_NAMESPACE::XMLFormatTarget *arg1 = (XERCES_CPP_NAMESPACE::XMLFormatTarget *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: XMLFormatTarget_flush(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLFormatTarget_flush" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLFormatTarget *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLFormatTarget * >(argp1);
+ {
+ try
+ {
+ (arg1)->flush();
+ }
+ CATCH_XML_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_XML_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_XML_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_XML_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_XML_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);");
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg1 = UTF8_TRANSCODER->Local2XMLString(ST(0));
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::LocalFileFormatTarget *)new XERCES_CPP_NAMESPACE::LocalFileFormatTarget((XMLCh const *)arg1);
+ }
+ CATCH_XML_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_XML_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_XML_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_XML_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_XML_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_XML_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_XML_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_XML_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_XML_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_XML_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_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_XERCES_CPP_NAMESPACE__XMLAttrTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLAttr *) 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__RefArrayVectorOfTuint16_t_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::BaseRefVectorOf<XMLCh > *) ((XERCES_CPP_NAMESPACE::RefArrayVectorOf<uint16_t > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::BaseRefVectorOf<uint16_t > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::BaseRefVectorOf<XERCES_CPP_NAMESPACE::XMLAttr > *) ((XERCES_CPP_NAMESPACE::RefVectorOf<XERCES_CPP_NAMESPACE::XMLAttr > *) 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__PSVIItemTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::PSVIItem *) 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__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__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__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__PSVIAttributeListTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::PSVIAttributeList *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__PSVIAttributeTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::PSVIItem *) ((XERCES_CPP_NAMESPACE::PSVIAttribute *) 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__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::BaseRefVectorOf<XERCES_CPP_NAMESPACE::XMLAttr > *) 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__PSVIElementTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::PSVIItem *) ((XERCES_CPP_NAMESPACE::PSVIElement *) 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 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__BinInputStream = {"_p_XERCES_CPP_NAMESPACE__BinInputStream", "XERCES_CPP_NAMESPACE::BinInputStream *", 0, 0, (void*)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__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__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__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__XMLFormatTarget = {"_p_XERCES_CPP_NAMESPACE__XMLFormatTarget", "XERCES_CPP_NAMESPACE::XMLFormatTarget *", 0, 0, (void*)"XML::Xerces::XMLFormatTarget", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLFormatter = {"_p_XERCES_CPP_NAMESPACE__XMLFormatter", "XERCES_CPP_NAMESPACE::XMLFormatter *", 0, 0, (void*)"XML::Xerces::XMLFormatter", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLTranscoder = {"_p_XERCES_CPP_NAMESPACE__XMLTranscoder", "XERCES_CPP_NAMESPACE::XMLTranscoder *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLURL = {"_p_XERCES_CPP_NAMESPACE__XMLURL", "XERCES_CPP_NAMESPACE::XMLURL *", 0, 0, (void*)"XML::Xerces::XMLURL", 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__XMLAttr = {"_p_XERCES_CPP_NAMESPACE__XMLAttr", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t = {"_p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t", 0, 0, 0, 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__SchemaValidator = {"_p_XERCES_CPP_NAMESPACE__SchemaValidator", 0, 0, 0, 0, 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__XMLValidator = {"_p_XERCES_CPP_NAMESPACE__XMLValidator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLPScanToken = {"_p_XERCES_CPP_NAMESPACE__XMLPScanToken", 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__DTDAttDef = {"_p_XERCES_CPP_NAMESPACE__DTDAttDef", 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__XMLNotationDecl = {"_p_XERCES_CPP_NAMESPACE__XMLNotationDecl", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t = {"_p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__PSVIItem = {"_p_XERCES_CPP_NAMESPACE__PSVIItem", 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__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t = {"_p_XERCES_CPP_NAMESPACE__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_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__BaseRefVectorOfTuint16_t_t = {"_p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_t", 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__SchemaGrammar = {"_p_XERCES_CPP_NAMESPACE__SchemaGrammar", 0, 0, 0, 0, 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__Grammar = {"_p_XERCES_CPP_NAMESPACE__Grammar", 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__PSVIAttributeList = {"_p_XERCES_CPP_NAMESPACE__PSVIAttributeList", 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__PSVIAttribute = {"_p_XERCES_CPP_NAMESPACE__PSVIAttribute", 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__PSVIElement = {"_p_XERCES_CPP_NAMESPACE__PSVIElement", 0, 0, 0, 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 *|XMLCh *", 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 *swig_type_initial[] = {
+ &_swigt__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__BinInputStream,
+ &_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__Grammar,
+ &_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__PSVIAttribute,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PSVIAttributeList,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PSVIElement,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PSVIItem,
+ &_swigt__p_XERCES_CPP_NAMESPACE__QName,
+ &_swigt__p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t,
+ &_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__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_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__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__XMLAttDef,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDefList,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLAttr,
+ &_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__XMLException,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatTarget,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatter,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLPScanToken,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLSchemaDescription,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLTranscoder,
+ &_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_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,
+};
+
+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__BinInputStream[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__BinInputStream, 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},{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__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__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__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__XMLTranscoder[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLTranscoder, 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__XMLAttr[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttr, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t, 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__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__SchemaValidator[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__SchemaValidator, 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__XMLValidator[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLValidator, 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__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__DTDAttDef[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef, 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__XMLNotationDecl[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__PSVIItem[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__PSVIItem, 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__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_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__BaseRefVectorOfTuint16_t_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_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__XMLContentModel[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLContentModel, 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__DTDGrammar[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__DTDGrammar, 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},{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__PSVIAttributeList[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__PSVIAttributeList, 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__PSVIAttribute[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__PSVIAttribute, 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__PSVIElement[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__PSVIElement, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMemory[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttr, _p_XERCES_CPP_NAMESPACE__XMLAttrTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t, _p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_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__DTDAttDef, _p_XERCES_CPP_NAMESPACE__DTDAttDefTo_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__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__RefArrayVectorOfTuint16_t_t, _p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__PSVIItem, _p_XERCES_CPP_NAMESPACE__PSVIItemTo_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__InputSource, _p_XERCES_CPP_NAMESPACE__InputSourceTo_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__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__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t, _p_XERCES_CPP_NAMESPACE__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_tTo_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__BaseRefVectorOfTuint16_t_t, _p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_tTo_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__SchemaGrammar, _p_XERCES_CPP_NAMESPACE__SchemaGrammarTo_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__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__PSVIAttributeList, _p_XERCES_CPP_NAMESPACE__PSVIAttributeListTo_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__PSVIAttribute, _p_XERCES_CPP_NAMESPACE__PSVIAttributeTo_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__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}, {&_swigt__p_XERCES_CPP_NAMESPACE__PSVIElement, _p_XERCES_CPP_NAMESPACE__PSVIElementTo_p_XERCES_CPP_NAMESPACE__XMemory, 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 *swig_cast_initial[] = {
+ _swigc__p_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__BinInputStream,
+ _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__Grammar,
+ _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__PSVIAttribute,
+ _swigc__p_XERCES_CPP_NAMESPACE__PSVIAttributeList,
+ _swigc__p_XERCES_CPP_NAMESPACE__PSVIElement,
+ _swigc__p_XERCES_CPP_NAMESPACE__PSVIItem,
+ _swigc__p_XERCES_CPP_NAMESPACE__QName,
+ _swigc__p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t,
+ _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__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_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__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__XMLAttDef,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLAttDefList,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLAttr,
+ _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__XMLException,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLFormatTarget,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLFormatter,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLGrammarDescription,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLNotationDecl,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLPScanToken,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLSchemaDescription,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLTranscoder,
+ _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_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,
+};
+
+
+/* -------- 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::delete_InputSource", _wrap_delete_InputSource},
+{"XML::Xercesc::InputSource_makeStream", _wrap_InputSource_makeStream},
+{"XML::Xercesc::InputSource_getEncoding", _wrap_InputSource_getEncoding},
+{"XML::Xercesc::InputSource_getPublicId", _wrap_InputSource_getPublicId},
+{"XML::Xercesc::InputSource_getSystemId", _wrap_InputSource_getSystemId},
+{"XML::Xercesc::InputSource_getIssueFatalErrorIfNotFound", _wrap_InputSource_getIssueFatalErrorIfNotFound},
+{"XML::Xercesc::InputSource_getMemoryManager", _wrap_InputSource_getMemoryManager},
+{"XML::Xercesc::InputSource_setEncoding", _wrap_InputSource_setEncoding},
+{"XML::Xercesc::InputSource_setPublicId", _wrap_InputSource_setPublicId},
+{"XML::Xercesc::InputSource_setSystemId", _wrap_InputSource_setSystemId},
+{"XML::Xercesc::InputSource_setIssueFatalErrorIfNotFound", _wrap_InputSource_setIssueFatalErrorIfNotFound},
+{"XML::Xercesc::new_LocalFileInputSource", _wrap_new_LocalFileInputSource},
+{"XML::Xercesc::delete_LocalFileInputSource", _wrap_delete_LocalFileInputSource},
+{"XML::Xercesc::LocalFileInputSource_makeStream", _wrap_LocalFileInputSource_makeStream},
+{"XML::Xercesc::new_StdInInputSource", _wrap_new_StdInInputSource},
+{"XML::Xercesc::delete_StdInInputSource", _wrap_delete_StdInInputSource},
+{"XML::Xercesc::StdInInputSource_makeStream", _wrap_StdInInputSource_makeStream},
+{"XML::Xercesc::new_URLInputSource", _wrap_new_URLInputSource},
+{"XML::Xercesc::delete_URLInputSource", _wrap_delete_URLInputSource},
+{"XML::Xercesc::URLInputSource_makeStream", _wrap_URLInputSource_makeStream},
+{"XML::Xercesc::URLInputSource_urlSrc", _wrap_URLInputSource_urlSrc},
+{"XML::Xercesc::new_MemBufInputSource", _wrap_new_MemBufInputSource},
+{"XML::Xercesc::delete_MemBufInputSource", _wrap_delete_MemBufInputSource},
+{"XML::Xercesc::MemBufInputSource_makeStream", _wrap_MemBufInputSource_makeStream},
+{"XML::Xercesc::MemBufInputSource_setCopyBufToStream", _wrap_MemBufInputSource_setCopyBufToStream},
+{"XML::Xercesc::MemBufInputSource_resetMemBufInputSource", _wrap_MemBufInputSource_resetMemBufInputSource},
+{"XML::Xercesc::new_XMLFormatter", _wrap_new_XMLFormatter},
+{"XML::Xercesc::delete_XMLFormatter", _wrap_delete_XMLFormatter},
+{"XML::Xercesc::XMLFormatter_formatBuf", _wrap_XMLFormatter_formatBuf},
+{"XML::Xercesc::XMLFormatter_writeBOM", _wrap_XMLFormatter_writeBOM},
+{"XML::Xercesc::XMLFormatter_getEncodingName", _wrap_XMLFormatter_getEncodingName},
+{"XML::Xercesc::XMLFormatter_getTranscoder", _wrap_XMLFormatter_getTranscoder},
+{"XML::Xercesc::XMLFormatter_setEscapeFlags", _wrap_XMLFormatter_setEscapeFlags},
+{"XML::Xercesc::XMLFormatter_setUnRepFlags", _wrap_XMLFormatter_setUnRepFlags},
+{"XML::Xercesc::XMLFormatter___lshift__", _wrap_XMLFormatter___lshift__},
+{"XML::Xercesc::XMLFormatter_getEscapeFlags", _wrap_XMLFormatter_getEscapeFlags},
+{"XML::Xercesc::XMLFormatter_getUnRepFlags", _wrap_XMLFormatter_getUnRepFlags},
+{"XML::Xercesc::delete_XMLFormatTarget", _wrap_delete_XMLFormatTarget},
+{"XML::Xercesc::XMLFormatTarget_writeChars", _wrap_XMLFormatTarget_writeChars},
+{"XML::Xercesc::XMLFormatTarget_flush", _wrap_XMLFormatTarget_flush},
+{"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},
+{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__Grammar->dcast = (swig_dycast_func) Grammar_dynamic_cast;
+
+
+ SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription->dcast = (swig_dycast_func) XMLGrammarDescription_dynamic_cast;
+
+
+ // 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_XERCES_CPP_NAMESPACE__InputSource, (void*) "XML::Xerces::InputSource");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileInputSource, (void*) "XML::Xerces::LocalFileInputSource");
+ 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 "XMLFormatter_NoEscapes", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::XMLFormatter::NoEscapes)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "XMLFormatter_StdEscapes", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::XMLFormatter::StdEscapes)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "XMLFormatter_AttrEscapes", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::XMLFormatter::AttrEscapes)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "XMLFormatter_CharEscapes", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::XMLFormatter::CharEscapes)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "XMLFormatter_EscapeFlags_Count", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::XMLFormatter::EscapeFlags_Count)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "XMLFormatter_DefaultEscape", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::XMLFormatter::DefaultEscape)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "XMLFormatter_UnRep_Fail", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::XMLFormatter::UnRep_Fail)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "XMLFormatter_UnRep_CharRef", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::XMLFormatter::UnRep_CharRef)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "XMLFormatter_UnRep_Replace", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::XMLFormatter::UnRep_Replace)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "XMLFormatter_DefaultUnRep", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::XMLFormatter::DefaultUnRep)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter, (void*) "XML::Xerces::XMLFormatter");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget, (void*) "XML::Xerces::XMLFormatTarget");
+ 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");
+ ST(0) = &PL_sv_yes;
+ XSRETURN(1);
+}
+
diff --git a/swig/perl/SAX/Makefile.PL b/swig/perl/SAX/Makefile.PL
new file mode 100644
index 0000000000000000000000000000000000000000..3f4e12cdd33ad3a119ea06e6250ac0d980502614
--- /dev/null
+++ b/swig/perl/SAX/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_SAX_postamble {
+ my $retval = <<TERMINUS;
+SAX-tmp.pm: $SCRIPTS_DIR/postModule.pl $INTERFACE_DIR/Perl/sax-shadow.i
+ \$(SWIG) $SWIG_ARGS -o Xerces_SAX-tmp.cpp -pm SAX-tmp.pm $INTERFACE_DIR/Xerces_SAX.i
+
+SAX.pm: $SCRIPTS_DIR/postModule.pl SAX-tmp.pm
+ perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postModule.pl --in=SAX-tmp.pm --out=SAX.pm
+
+Xerces_SAX.cpp: $SCRIPTS_DIR/postSource.pl Xerces_SAX-tmp.cpp
+ perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postSource.pl --in=Xerces_SAX-tmp.cpp --out=Xerces_SAX.cpp
+
+Xerces_SAX-tmp.cpp: $INTERFACE_DIR/Xerces_SAX.i @SAX_INTERFACE_FILES
+ \$(SWIG) $SWIG_ARGS -o Xerces_SAX-tmp.cpp -pm SAX-tmp.pm $INTERFACE_DIR/Xerces_SAX.i
+ perl -I$SCRIPTS_DIR $SCRIPTS_DIR/postModule.pl --in=SAX-tmp.pm --out=SAX.pm
+ mkdir -p $BLIB_DIR
+ cp -f SAX.pm $BLIB_DIR/SAX.pm
+
+TERMINUS
+ return $retval;
+ }
+
+ *MY::postamble = \&Xerces_SAX_postamble;
+}
+
+WriteMakefile(
+ 'NAME' => 'XML::Xerces::SAX',
+ 'INC' => $INCLUDES,
+ 'LIBS' => [$LIBS],
+ 'MYEXTLIB' => "$TRANSCODER_LIB $HANDLER_LIB",
+ 'OBJECT' => 'Xerces_SAX$(OBJ_EXT)',
+ 'CCFLAGS' => $CFLAGS,
+ 'CC' => $CXX,
+ 'SKIP' => [qw( test makeaperl xs_o)],
+ @OPTIMIZE,
+ @LDFLAGS,
+);
+
diff --git a/swig/perl/SAX/SAX.pm b/swig/perl/SAX/SAX.pm
new file mode 100644
index 0000000000000000000000000000000000000000..039d6a4a1d53ac14f36c69aea5e00d77619ce143
--- /dev/null
+++ b/swig/perl/SAX/SAX.pm
@@ -0,0 +1,834 @@
+ #
+ # 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::SAX;
+use base qw(DynaLoader);
+require XML::Xerces;
+require XML::Xerces::IO;
+bootstrap XML::Xerces::SAX;
+package XML::Xerces::SAX;
+############# Class : XML::Xerces::PerlDefaultHandler ##############
+package XML::Xerces::PerlDefaultHandler;
+use vars qw(@ISA);
+@ISA = qw(XML::Xerces::ContentHandler
+ XML::Xerces::DocumentHandler);
+sub new {
+ my $class = shift;
+
+ # support copy constructor syntax
+ $class = ref($class) if ref($class);
+
+ return bless {}, $class;
+}
+
+sub startElement {
+ my $self = shift;
+ $self->start_element(@_);
+}
+sub endElement {
+ my $self = shift;
+ $self->end_element(@_);
+}
+sub startPrefixMapping {
+ my $self = shift;
+ $self->start_prefix_mapping(@_);
+}
+sub endPrefixMapping {
+ my $self = shift;
+ $self->end_prefix_mapping(@_);
+}
+sub skippedEntity {
+ my $self = shift;
+ $self->skipped_entity(@_);
+}
+sub startDocument {
+ my $self = shift;
+ $self->start_document();
+}
+sub endDocument {
+ my $self = shift;
+ $self->end_document();
+}
+sub resetDocument {
+ my $self = shift;
+ $self->reset_document();
+}
+sub characters {}
+sub processingInstruction {
+ my $self = shift;
+ $self->processing_instruction(@_);
+}
+sub setDocumentLocator {
+ my $self = shift;
+ $self->set_document_locator(@_);
+}
+sub ignorableWhitespace {
+ my $self = shift;
+ $self->ignorable_whitespace(@_);
+}
+
+#
+# support alternate Perl-friendly syntax
+#
+sub start_element {}
+sub end_element {}
+sub start_prefix_mapping {}
+sub end_prefix_mapping {}
+sub skipped_entity {}
+sub start_document {}
+sub end_document {}
+sub reset_document {}
+sub processing_instruction {}
+sub set_document_locator {}
+sub ignorable_whitespace {}
+
+
+############# Class : XML::Xerces::PerlContentHandler ##############
+package XML::Xerces::PerlContentHandler;
+use vars qw(@ISA);
+@ISA = qw(XML::Xerces::PerlDefaultHandler);
+
+############# Class : XML::Xerces::PerlDocumentHandler ##############
+package XML::Xerces::PerlDocumentHandler;
+use vars qw(@ISA);
+@ISA = qw(XML::Xerces::PerlDefaultHandler);
+
+package XML::Xerces::Attributes;
+sub to_hash {
+ my $self = shift;
+ my %hash;
+ for (my $i=0; $i < $self->getLength(); $i++) {
+ my $qname = $self->getQName($i);
+ $hash{$qname}->{localName} = $self->getLocalName($i);
+ $hash{$qname}->{URI} = $self->getURI($i);
+ $hash{$qname}->{value} = $self->getValue($i);
+ $hash{$qname}->{type} = $self->getType($i);
+ }
+ return %hash;
+}
+
+package XML::Xerces::AttributeList;
+sub to_hash {
+ my $self = shift;
+ my %hash;
+ for (my $i=0;$i<$self->getLength();$i++) {
+ $hash{$self->getName($i)} = $self->getValue($i)
+ }
+ return %hash;
+}
+
+
+# ------- FUNCTION WRAPPERS --------
+
+package XML::Xerces;
+
+
+############# 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::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::Parser ##############
+
+package XML::Xerces::Parser;
+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_Parser($self);
+ delete $OWNER{$self};
+ }
+}
+
+sub setEntityResolver {
+ my ($self,$handler) = @_;
+
+
+ my $callback;
+ if (defined$handler) {
+ $callback = XML::Xerces::PerlEntityResolverHandler->new($handler);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__ENTITY_RESOLVER} = $callback;
+ }
+ return XML::Xercesc::Parser_setEntityResolver($self,$callback);
+}
+
+*setDTDHandler = *XML::Xercesc::Parser_setDTDHandler;
+*setDocumentHandler = *XML::Xercesc::Parser_setDocumentHandler;
+sub setErrorHandler {
+ my ($self,$handler) = @_;
+
+
+ my $callback;
+ if (defined$handler) {
+ $callback = XML::Xerces::PerlErrorCallbackHandler->new($handler);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__ERROR_HANDLER} = $callback;
+ }
+ return XML::Xercesc::Parser_setErrorHandler($self,$callback);
+}
+
+*parse = *XML::Xercesc::Parser_parse;
+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::SAXParser ##############
+
+package XML::Xerces::SAXParser;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::Parser XML::Xerces::XMLDocumentHandler XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+*Val_Never = *XML::Xercesc::SAXParser_Val_Never;
+*Val_Always = *XML::Xercesc::SAXParser_Val_Always;
+*Val_Auto = *XML::Xercesc::SAXParser_Val_Auto;
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_SAXParser(@_);
+ 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_SAXParser($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getDocumentHandler = *XML::Xercesc::SAXParser_getDocumentHandler;
+*getEntityResolver = *XML::Xercesc::SAXParser_getEntityResolver;
+*getXMLEntityResolver = *XML::Xercesc::SAXParser_getXMLEntityResolver;
+*getErrorHandler = *XML::Xercesc::SAXParser_getErrorHandler;
+*getPSVIHandler = *XML::Xercesc::SAXParser_getPSVIHandler;
+*getValidator = *XML::Xercesc::SAXParser_getValidator;
+*getValidationScheme = *XML::Xercesc::SAXParser_getValidationScheme;
+*getDoSchema = *XML::Xercesc::SAXParser_getDoSchema;
+*getValidationSchemaFullChecking = *XML::Xercesc::SAXParser_getValidationSchemaFullChecking;
+*getIdentityConstraintChecking = *XML::Xercesc::SAXParser_getIdentityConstraintChecking;
+*getErrorCount = *XML::Xercesc::SAXParser_getErrorCount;
+*getDoNamespaces = *XML::Xercesc::SAXParser_getDoNamespaces;
+*getExitOnFirstFatalError = *XML::Xercesc::SAXParser_getExitOnFirstFatalError;
+*getValidationConstraintFatal = *XML::Xercesc::SAXParser_getValidationConstraintFatal;
+*getExternalSchemaLocation = *XML::Xercesc::SAXParser_getExternalSchemaLocation;
+*getExternalNoNamespaceSchemaLocation = *XML::Xercesc::SAXParser_getExternalNoNamespaceSchemaLocation;
+*getSecurityManager = *XML::Xercesc::SAXParser_getSecurityManager;
+*getLoadExternalDTD = *XML::Xercesc::SAXParser_getLoadExternalDTD;
+*isCachingGrammarFromParse = *XML::Xercesc::SAXParser_isCachingGrammarFromParse;
+*isUsingCachedGrammarInParse = *XML::Xercesc::SAXParser_isUsingCachedGrammarInParse;
+*getCalculateSrcOfs = *XML::Xercesc::SAXParser_getCalculateSrcOfs;
+*getStandardUriConformant = *XML::Xercesc::SAXParser_getStandardUriConformant;
+*getGrammar = *XML::Xercesc::SAXParser_getGrammar;
+*getRootGrammar = *XML::Xercesc::SAXParser_getRootGrammar;
+*getURIText = *XML::Xercesc::SAXParser_getURIText;
+*getSrcOffset = *XML::Xercesc::SAXParser_getSrcOffset;
+*getGenerateSyntheticAnnotations = *XML::Xercesc::SAXParser_getGenerateSyntheticAnnotations;
+*getValidateAnnotations = *XML::Xercesc::SAXParser_getValidateAnnotations;
+*getIgnoreCachedDTD = *XML::Xercesc::SAXParser_getIgnoreCachedDTD;
+*getIgnoreAnnotations = *XML::Xercesc::SAXParser_getIgnoreAnnotations;
+*getDisableDefaultEntityResolution = *XML::Xercesc::SAXParser_getDisableDefaultEntityResolution;
+*getSkipDTDValidation = *XML::Xercesc::SAXParser_getSkipDTDValidation;
+*setGenerateSyntheticAnnotations = *XML::Xercesc::SAXParser_setGenerateSyntheticAnnotations;
+*setValidateAnnotations = *XML::Xercesc::SAXParser_setValidateAnnotations;
+*setDoNamespaces = *XML::Xercesc::SAXParser_setDoNamespaces;
+*setValidationScheme = *XML::Xercesc::SAXParser_setValidationScheme;
+*setDoSchema = *XML::Xercesc::SAXParser_setDoSchema;
+*setValidationSchemaFullChecking = *XML::Xercesc::SAXParser_setValidationSchemaFullChecking;
+*setIdentityConstraintChecking = *XML::Xercesc::SAXParser_setIdentityConstraintChecking;
+*setExitOnFirstFatalError = *XML::Xercesc::SAXParser_setExitOnFirstFatalError;
+*setValidationConstraintFatal = *XML::Xercesc::SAXParser_setValidationConstraintFatal;
+*setExternalSchemaLocation = *XML::Xercesc::SAXParser_setExternalSchemaLocation;
+*setExternalNoNamespaceSchemaLocation = *XML::Xercesc::SAXParser_setExternalNoNamespaceSchemaLocation;
+*setSecurityManager = *XML::Xercesc::SAXParser_setSecurityManager;
+*setLoadExternalDTD = *XML::Xercesc::SAXParser_setLoadExternalDTD;
+*cacheGrammarFromParse = *XML::Xercesc::SAXParser_cacheGrammarFromParse;
+*useCachedGrammarInParse = *XML::Xercesc::SAXParser_useCachedGrammarInParse;
+*setCalculateSrcOfs = *XML::Xercesc::SAXParser_setCalculateSrcOfs;
+*setStandardUriConformant = *XML::Xercesc::SAXParser_setStandardUriConformant;
+*useScanner = *XML::Xercesc::SAXParser_useScanner;
+*setInputBufferSize = *XML::Xercesc::SAXParser_setInputBufferSize;
+*setIgnoreCachedDTD = *XML::Xercesc::SAXParser_setIgnoreCachedDTD;
+*setIgnoreAnnotations = *XML::Xercesc::SAXParser_setIgnoreAnnotations;
+*setDisableDefaultEntityResolution = *XML::Xercesc::SAXParser_setDisableDefaultEntityResolution;
+*setSkipDTDValidation = *XML::Xercesc::SAXParser_setSkipDTDValidation;
+*installAdvDocHandler = *XML::Xercesc::SAXParser_installAdvDocHandler;
+*removeAdvDocHandler = *XML::Xercesc::SAXParser_removeAdvDocHandler;
+*parseFirst = *XML::Xercesc::SAXParser_parseFirst;
+*parseNext = *XML::Xercesc::SAXParser_parseNext;
+*parseReset = *XML::Xercesc::SAXParser_parseReset;
+*loadGrammar = *XML::Xercesc::SAXParser_loadGrammar;
+*resetCachedGrammarPool = *XML::Xercesc::SAXParser_resetCachedGrammarPool;
+*parse = *XML::Xercesc::SAXParser_parse;
+sub setDocumentHandler {
+ my ($self,$handler) = @_;
+ my $callback = XML::Xerces::PerlSAXCallbackHandler->new($handler);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__DOCUMENT_HANDLER} = $callback;
+
+ my @args = ($self,$callback);
+ return XML::Xercesc::SAXParser_setDocumentHandler(@args);
+}
+
+*setDTDHandler = *XML::Xercesc::SAXParser_setDTDHandler;
+sub setErrorHandler {
+ my ($self,$handler) = @_;
+
+
+ my $callback;
+ if (defined$handler) {
+ $callback = XML::Xerces::PerlErrorCallbackHandler->new($handler);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__ERROR_HANDLER} = $callback;
+ }
+ return XML::Xercesc::SAXParser_setErrorHandler($self,$callback);
+}
+
+*setPSVIHandler = *XML::Xercesc::SAXParser_setPSVIHandler;
+sub setEntityResolver {
+ my ($self,$handler) = @_;
+
+
+ my $callback;
+ if (defined$handler) {
+ $callback = XML::Xerces::PerlEntityResolverHandler->new($handler);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__ENTITY_RESOLVER} = $callback;
+ }
+ return XML::Xercesc::SAXParser_setEntityResolver($self,$callback);
+}
+
+*setXMLEntityResolver = *XML::Xercesc::SAXParser_setXMLEntityResolver;
+*error = *XML::Xercesc::SAXParser_error;
+*resetErrors = *XML::Xercesc::SAXParser_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::SAX2XMLReader ##############
+
+package XML::Xerces::SAX2XMLReader;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+*Val_Never = *XML::Xercesc::SAX2XMLReader_Val_Never;
+*Val_Always = *XML::Xercesc::SAX2XMLReader_Val_Always;
+*Val_Auto = *XML::Xercesc::SAX2XMLReader_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_SAX2XMLReader($self);
+ delete $OWNER{$self};
+ }
+}
+
+*getContentHandler = *XML::Xercesc::SAX2XMLReader_getContentHandler;
+*getDTDHandler = *XML::Xercesc::SAX2XMLReader_getDTDHandler;
+*getFeature = *XML::Xercesc::SAX2XMLReader_getFeature;
+*getProperty = *XML::Xercesc::SAX2XMLReader_getProperty;
+sub setContentHandler {
+ my ($self,$handler) = @_;
+ my $callback = XML::Xerces::PerlSAXCallbackHandler->new($handler);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__CONTENT_HANDLER} = $callback;
+
+ my @args = ($self,$callback);
+ return XML::Xercesc::SAX2XMLReader_setContentHandler(@args);
+}
+
+*setDTDHandler = *XML::Xercesc::SAX2XMLReader_setDTDHandler;
+sub setEntityResolver {
+ my ($self,$handler) = @_;
+
+
+ my $callback;
+ if (defined$handler) {
+ $callback = XML::Xerces::PerlEntityResolverHandler->new($handler);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__ENTITY_RESOLVER} = $callback;
+ }
+ return XML::Xercesc::SAX2XMLReader_setEntityResolver($self,$callback);
+}
+
+sub setErrorHandler {
+ my ($self,$handler) = @_;
+
+
+ my $callback;
+ if (defined$handler) {
+ $callback = XML::Xerces::PerlErrorCallbackHandler->new($handler);
+ $XML::Xerces::REMEMBER{tied(% {$self})}->{__ERROR_HANDLER} = $callback;
+ }
+ return XML::Xercesc::SAX2XMLReader_setErrorHandler($self,$callback);
+}
+
+*setFeature = *XML::Xercesc::SAX2XMLReader_setFeature;
+*setProperty = *XML::Xercesc::SAX2XMLReader_setProperty;
+*parse = *XML::Xercesc::SAX2XMLReader_parse;
+*getDeclarationHandler = *XML::Xercesc::SAX2XMLReader_getDeclarationHandler;
+*getLexicalHandler = *XML::Xercesc::SAX2XMLReader_getLexicalHandler;
+*setDeclarationHandler = *XML::Xercesc::SAX2XMLReader_setDeclarationHandler;
+*setLexicalHandler = *XML::Xercesc::SAX2XMLReader_setLexicalHandler;
+*getValidator = *XML::Xercesc::SAX2XMLReader_getValidator;
+*getErrorCount = *XML::Xercesc::SAX2XMLReader_getErrorCount;
+*getExitOnFirstFatalError = *XML::Xercesc::SAX2XMLReader_getExitOnFirstFatalError;
+*getValidationConstraintFatal = *XML::Xercesc::SAX2XMLReader_getValidationConstraintFatal;
+*getGrammar = *XML::Xercesc::SAX2XMLReader_getGrammar;
+*getRootGrammar = *XML::Xercesc::SAX2XMLReader_getRootGrammar;
+*getURIText = *XML::Xercesc::SAX2XMLReader_getURIText;
+*getSrcOffset = *XML::Xercesc::SAX2XMLReader_getSrcOffset;
+*setValidator = *XML::Xercesc::SAX2XMLReader_setValidator;
+*setExitOnFirstFatalError = *XML::Xercesc::SAX2XMLReader_setExitOnFirstFatalError;
+*setValidationConstraintFatal = *XML::Xercesc::SAX2XMLReader_setValidationConstraintFatal;
+*parseFirst = *XML::Xercesc::SAX2XMLReader_parseFirst;
+*parseNext = *XML::Xercesc::SAX2XMLReader_parseNext;
+*parseReset = *XML::Xercesc::SAX2XMLReader_parseReset;
+*loadGrammar = *XML::Xercesc::SAX2XMLReader_loadGrammar;
+*resetCachedGrammarPool = *XML::Xercesc::SAX2XMLReader_resetCachedGrammarPool;
+*setInputBufferSize = *XML::Xercesc::SAX2XMLReader_setInputBufferSize;
+*installAdvDocHandler = *XML::Xercesc::SAX2XMLReader_installAdvDocHandler;
+*removeAdvDocHandler = *XML::Xercesc::SAX2XMLReader_removeAdvDocHandler;
+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::XMLReaderFactory ##############
+
+package XML::Xerces::XMLReaderFactory;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+*createXMLReader = *XML::Xercesc::XMLReaderFactory_createXMLReader;
+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::PerlSAXCallbackHandler ##############
+
+package XML::Xerces::PerlSAXCallbackHandler;
+use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
+@ISA = qw( XML::Xerces::ContentHandler XML::Xerces::DocumentHandler XML::Xerces::PerlCallbackHandler XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+sub new {
+ my $pkg = shift;
+ my $self = XML::Xercesc::new_PerlSAXCallbackHandler(@_);
+ 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_PerlSAXCallbackHandler($self);
+ delete $OWNER{$self};
+ }
+}
+
+*type = *XML::Xercesc::PerlSAXCallbackHandler_type;
+*characters = *XML::Xercesc::PerlSAXCallbackHandler_characters;
+*processingInstruction = *XML::Xercesc::PerlSAXCallbackHandler_processingInstruction;
+*setDocumentLocator = *XML::Xercesc::PerlSAXCallbackHandler_setDocumentLocator;
+*startPrefixMapping = *XML::Xercesc::PerlSAXCallbackHandler_startPrefixMapping;
+*endPrefixMapping = *XML::Xercesc::PerlSAXCallbackHandler_endPrefixMapping;
+*skippedEntity = *XML::Xercesc::PerlSAXCallbackHandler_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;
+}
+
+
+# ------- VARIABLE STUBS --------
+
+package XML::Xerces;
+
+1;
diff --git a/swig/perl/SAX/Xerces_SAX.cpp b/swig/perl/SAX/Xerces_SAX.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c76d6906bd15546646e1938ad56f191b0430bc4a
--- /dev/null
+++ b/swig/perl/SAX/Xerces_SAX.cpp
@@ -0,0 +1,13793 @@
+/*
+ * 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_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t swig_types[0]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList swig_types[1]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes swig_types[2]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t swig_types[3]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_t swig_types[4]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler swig_types[5]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDAttDef swig_types[6]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDAttDefList swig_types[7]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDElementDecl swig_types[8]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDEntityDecl swig_types[9]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDGrammar swig_types[10]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler swig_types[11]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDValidator swig_types[12]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler swig_types[13]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler swig_types[14]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__EntityResolver swig_types[15]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__ErrorHandler swig_types[16]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Grammar swig_types[17]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase swig_types[18]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__InputSource swig_types[19]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler swig_types[20]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget swig_types[21]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__LocalFileInputSource swig_types[22]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator swig_types[23]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget swig_types[24]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemBufInputSource swig_types[25]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager swig_types[26]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[27]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolEnumeratorTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[28]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDElementDecl_t swig_types[29]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__NameIdPoolTXERCES_CPP_NAMESPACE__DTDEntityDecl_t swig_types[30]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIAttribute swig_types[31]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIAttributeList swig_types[32]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIElement swig_types[33]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIHandler swig_types[34]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PSVIItem swig_types[35]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__Parser swig_types[36]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlCallbackHandler swig_types[37]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandler swig_types[38]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlErrorCallbackHandler swig_types[39]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler swig_types[40]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__QName swig_types[41]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t swig_types[42]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolEnumeratorTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[43]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefHash3KeysIdPoolTXERCES_CPP_NAMESPACE__SchemaElementDecl_t swig_types[44]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t swig_types[45]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader swig_types[46]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXException swig_types[47]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException swig_types[48]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException swig_types[49]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParseException swig_types[50]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser swig_types[51]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaAttDef swig_types[52]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaAttDefList swig_types[53]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaElementDecl swig_types[54]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaGrammar swig_types[55]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaValidator swig_types[56]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__SecurityManager swig_types[57]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdInInputSource swig_types[58]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget swig_types[59]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__URLInputSource swig_types[60]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttDef swig_types[61]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttDefList swig_types[62]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLAttr swig_types[63]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLContentModel swig_types[64]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDTDDescription swig_types[65]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDocumentHandler swig_types[66]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLElementDecl swig_types[67]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityDecl swig_types[68]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityResolver swig_types[69]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLException swig_types[70]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatTarget swig_types[71]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLFormatter swig_types[72]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription swig_types[73]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool swig_types[74]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLNotationDecl swig_types[75]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLPScanToken swig_types[76]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLReaderFactory swig_types[77]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLSchemaDescription swig_types[78]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLURL swig_types[79]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLUri swig_types[80]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator swig_types[81]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMemory swig_types[82]
+#define SWIGTYPE_p_XMLErrorReporter__ErrTypes swig_types[83]
+#define SWIGTYPE_p_char swig_types[84]
+#define SWIGTYPE_p_int32_t swig_types[85]
+#define SWIGTYPE_p_size_t swig_types[86]
+#define SWIGTYPE_p_ssize_t swig_types[87]
+#define SWIGTYPE_p_uint16_t swig_types[88]
+#define SWIGTYPE_p_uint32_t swig_types[89]
+#define SWIGTYPE_p_unsigned_char swig_types[90]
+#define SWIGTYPE_p_void swig_types[91]
+static swig_type_info *swig_types[93];
+static swig_module_info swig_module = {swig_types, 92, 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__SAX
+
+#define SWIG_name "XML::Xercesc::boot_XML__Xerces__SAX"
+#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/framework/LocalFileInputSource.hpp"
+#include "xercesc/framework/MemBufInputSource.hpp"
+#include "xercesc/framework/StdInInputSource.hpp"
+#include "xercesc/framework/URLInputSource.hpp"
+
+#include "xercesc/framework/XMLFormatter.hpp"
+#include "xercesc/framework/MemBufFormatTarget.hpp"
+#include "xercesc/framework/LocalFileFormatTarget.hpp"
+#include "xercesc/framework/StdOutFormatTarget.hpp"
+
+
+
+
+#include "xercesc/sax/Locator.hpp"
+#include "xercesc/sax/HandlerBase.hpp"
+#include "xercesc/parsers/SAXParser.hpp"
+
+#include "xercesc/sax2/Attributes.hpp"
+#include "xercesc/sax2/ContentHandler.hpp"
+#include "xercesc/sax2/LexicalHandler.hpp"
+#include "xercesc/sax2/DeclHandler.hpp"
+#include "xercesc/sax2/SAX2XMLReader.hpp"
+#include "xercesc/sax2/XMLReaderFactory.hpp"
+
+
+
+
+XERCES_CPP_NAMESPACE_USE
+
+void
+makeSAXNotRecognizedException(const SAXNotRecognizedException& e){
+ SV *error = ERRSV;
+ SWIG_MakePtr(error, (void *) new SAXNotRecognizedException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotRecognizedException, SWIG_SHADOW|0);
+}
+
+void
+makeSAXNotSupportedException(const SAXNotSupportedException& e){
+ SV *error = ERRSV;
+ SWIG_MakePtr(error, (void *) new SAXNotSupportedException(e), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXNotSupportedException, SWIG_SHADOW|0);
+}
+
+
+
+#include "xercesc/sax/SAXException.hpp"
+#include "xercesc/sax/SAXParseException.hpp"
+#include "xercesc/sax/EntityResolver.hpp"
+
+#include "xercesc/util/PlatformUtils.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/util/NameIdPool.hpp"
+#include "xercesc/util/XMLEnumerator.hpp"
+#include "xercesc/util/SecurityManager.hpp"
+#include "xercesc/util/XMLException.hpp"
+#include "xercesc/util/XMLEntityResolver.hpp"
+
+#include "xercesc/framework/XMLValidator.hpp"
+#include "xercesc/framework/XMLDocumentHandler.hpp"
+#include "xercesc/framework/XMLPScanToken.hpp"
+
+#include "xercesc/framework/psvi/PSVIHandler.hpp"
+#include "xercesc/framework/psvi/PSVIItem.hpp"
+#include "xercesc/framework/psvi/PSVIElement.hpp"
+#include "xercesc/framework/psvi/PSVIAttribute.hpp"
+#include "xercesc/framework/psvi/PSVIAttributeList.hpp"
+
+#include "xercesc/framework/XMLGrammarDescription.hpp"
+#include "xercesc/framework/XMLDTDDescription.hpp"
+#include "xercesc/framework/XMLSchemaDescription.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 "PSVIWriter/PSVIUni.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);
+ }
+}
+
+
+
+
+
+
+#include "Transcoder.hpp"
+#include "XMLExceptionHandler.hpp"
+
+#include "PerlCallbackHandler.hpp"
+#include "PerlErrorCallbackHandler.hpp"
+#include "PerlDOMCallbackHandler.hpp"
+#include "PerlEntityResolverHandler.hpp"
+
+
+
+
+// we initialize the static UTF-8 transcoding info
+// these are used by the typemaps to convert between
+// Xerces internal UTF-16 and the scripting language format
+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);
+}
+
+/*
+ * The generic 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_XML_EXCEPTION \
+ catch (const XMLException& e) \
+ { \
+ makeXMLException(e); \
+ goto fail; \
+ } \
+ catch (...) \
+ { \
+ SWIG_croak("Handling Unknown exception"); \
+ goto fail; \
+ }
+
+
+
+static swig_type_info *
+Grammar_dynamic_cast(void **ptr) {
+ Grammar **nptr = (Grammar **) ptr;
+ if (*nptr == NULL) {
+ return NULL;
+ }
+ short int type = (*nptr)->getGrammarType();
+ if (type == Grammar::DTDGrammarType) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDGrammar;
+ }
+ if (type == Grammar::SchemaGrammarType) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__SchemaGrammar;
+ }
+ return NULL;
+}
+
+
+static swig_type_info *
+XMLGrammarDescription_dynamic_cast(void **ptr) {
+ XMLGrammarDescription **nptr = (XMLGrammarDescription **) ptr;
+ if (*nptr == NULL) {
+ return NULL;
+ }
+ short int type = (*nptr)->getGrammarType();
+ if (type == Grammar::DTDGrammarType) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDTDDescription;
+ }
+ if (type == Grammar::SchemaGrammarType) {
+ return SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLSchemaDescription;
+ }
+ return NULL;
+}
+
+
+
+#include "PerlSAXCallbackHandler.hpp"
+
+
+
+#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_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;
+}
+
+
+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_long SWIG_PERL_DECL_ARGS_1(unsigned long value)
+{
+ SV *obj = sv_newmortal();
+ sv_setuv(obj, (UV) value);
+ return obj;
+}
+
+
+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_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));
+}
+
+
+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);
+}
+
+
+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 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;
+}
+
+
+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_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 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 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;
+}
+
+
+
+
+
+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;
+}
+
+
+#define CATCH_SAX_EXCEPTION \
+ catch (const XMLException& e) \
+ { \
+ makeXMLException(e); \
+ goto fail; \
+ } \
+ catch (const SAXNotSupportedException& e) \
+ { \
+ makeSAXNotSupportedException(e); \
+ goto fail; \
+ } \
+ catch (const SAXNotRecognizedException& e) \
+ { \
+ makeSAXNotRecognizedException(e); \
+ goto fail; \
+ } \
+ catch (...) \
+ { \
+ SWIG_croak("Handling Unknown exception"); \
+ goto fail; \
+ }
+
+#ifdef PERL_OBJECT
+#define MAGIC_CLASS _wrap_XML__Xerces__SAX_var::
+class _wrap_XML__Xerces__SAX_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_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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+
+ // we convert *everything* into a string *including* undef
+ arg4 = UTF8_TRANSCODER->Local2XMLString(ST(3));
+
+
+ // we convert *everything* into a string *including* undef
+ arg5 = UTF8_TRANSCODER->Local2XMLString(ST(4));
+
+ {
+ try
+ {
+ (arg1)->unparsedEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5);
+ }
+ CATCH_XML_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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+ {
+ try
+ {
+ (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_XML_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_XML_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_XML_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_XML_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_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getType((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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 = 1;
+ }
+ }
+ 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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::AttributeList const *)arg1)->getValue((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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 = 1;
+ }
+ }
+ 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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+ {
+ try
+ {
+ (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_XML_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_XML_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_XML_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_XML_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_XML_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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+
+ // we convert *everything* into a string *including* undef
+ arg4 = UTF8_TRANSCODER->Local2XMLString(ST(3));
+
+
+ // we convert *everything* into a string *including* undef
+ arg5 = UTF8_TRANSCODER->Local2XMLString(ST(4));
+
+ {
+ try
+ {
+ (arg1)->unparsedEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5);
+ }
+ CATCH_XML_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_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_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_XML_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_XML_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_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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_XML_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_XML_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_XML_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_XML_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_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+ {
+ try
+ {
+ result = (int)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getIndex((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ result = (int)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getIndex((XMLCh const *)arg2);
+ }
+ CATCH_XML_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 = 1;
+ }
+ }
+ 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 = 1;
+ }
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getType((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getType((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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 = 1;
+ }
+ }
+ 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 = 1;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getValue((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::Attributes const *)arg1)->getValue((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(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 = 1;
+ }
+ }
+ 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 = 1;
+ }
+ }
+ if (!_v) goto check_3;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+ {
+ try
+ {
+ (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_XML_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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+ {
+ try
+ {
+ (arg1)->startPrefixMapping((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->endPrefixMapping((XMLCh const *)arg2);
+ }
+ CATCH_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->skippedEntity((XMLCh const *)arg2);
+ }
+ CATCH_XML_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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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_XML_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_XML_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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->endEntity((XMLCh const *)arg2);
+ }
+ CATCH_XML_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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+
+ // we convert *everything* into a string *including* undef
+ arg4 = UTF8_TRANSCODER->Local2XMLString(ST(3));
+
+ {
+ try
+ {
+ (arg1)->startDTD((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
+ }
+ CATCH_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->startEntity((XMLCh const *)arg2);
+ }
+ CATCH_XML_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_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+
+ // we convert *everything* into a string *including* undef
+ arg4 = UTF8_TRANSCODER->Local2XMLString(ST(3));
+
+
+ // we convert *everything* into a string *including* undef
+ arg5 = UTF8_TRANSCODER->Local2XMLString(ST(4));
+
+
+ // we convert *everything* into a string *including* undef
+ arg6 = UTF8_TRANSCODER->Local2XMLString(ST(5));
+
+ {
+ try
+ {
+ (arg1)->attributeDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5,(XMLCh const *)arg6);
+ }
+ CATCH_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+ {
+ try
+ {
+ (arg1)->internalEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_XML_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);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+
+ // we convert *everything* into a string *including* undef
+ arg4 = UTF8_TRANSCODER->Local2XMLString(ST(3));
+
+ {
+ try
+ {
+ (arg1)->externalEntityDecl((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+
+ delete[] arg4;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_Parser) {
+ {
+ XERCES_CPP_NAMESPACE::Parser *arg1 = (XERCES_CPP_NAMESPACE::Parser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_Parser(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Parser, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Parser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Parser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Parser * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Parser_setEntityResolver) {
+ {
+ XERCES_CPP_NAMESPACE::Parser *arg1 = (XERCES_CPP_NAMESPACE::Parser *) 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: Parser_setEntityResolver(self,resolver);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Parser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parser_setEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Parser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Parser * >(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 '" "Parser_setEntityResolver" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::EntityResolver *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::EntityResolver * >(argp2);
+ {
+ try
+ {
+ (arg1)->setEntityResolver(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Parser_setDTDHandler) {
+ {
+ XERCES_CPP_NAMESPACE::Parser *arg1 = (XERCES_CPP_NAMESPACE::Parser *) 0 ;
+ XERCES_CPP_NAMESPACE::DTDHandler *arg2 = (XERCES_CPP_NAMESPACE::DTDHandler *) (XERCES_CPP_NAMESPACE::DTDHandler *)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: Parser_setDTDHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Parser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parser_setDTDHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Parser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Parser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Parser_setDTDHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DTDHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DTDHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setDTDHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Parser_setDocumentHandler) {
+ {
+ XERCES_CPP_NAMESPACE::Parser *arg1 = (XERCES_CPP_NAMESPACE::Parser *) 0 ;
+ XERCES_CPP_NAMESPACE::DocumentHandler *arg2 = (XERCES_CPP_NAMESPACE::DocumentHandler *) (XERCES_CPP_NAMESPACE::DocumentHandler *)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: Parser_setDocumentHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Parser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parser_setDocumentHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Parser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Parser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Parser_setDocumentHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DocumentHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DocumentHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setDocumentHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Parser_setErrorHandler) {
+ {
+ XERCES_CPP_NAMESPACE::Parser *arg1 = (XERCES_CPP_NAMESPACE::Parser *) 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: Parser_setErrorHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Parser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parser_setErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Parser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Parser * >(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 '" "Parser_setErrorHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setErrorHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Parser_parse__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::Parser *arg1 = (XERCES_CPP_NAMESPACE::Parser *) 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: Parser_parse(self,source);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Parser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parser_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Parser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Parser * >(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 '" "Parser_parse" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Parser_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_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Parser_parse__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::Parser *arg1 = (XERCES_CPP_NAMESPACE::Parser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: Parser_parse(self,systemId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__Parser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parser_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::Parser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::Parser * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->parse((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_Parser_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__Parser, 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__Parser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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_Parser_parse__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_Parser_parse__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'Parser_parse'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_new_SAXParser__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::SAXParser *result = 0 ;
+ 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_SAXParser(valToAdopt,manager,gramPool);");
+ }
+ {
+ if (ST(0) != &PL_sv_undef) {
+ int rc = SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator, SWIG_POINTER_DISOWN | 0);
+ if (!SWIG_IsOK(rc)) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "new_SAXParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLValidator *const""'");
+ }
+ }
+ }
+ 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_SAXParser" "', 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_SAXParser" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLGrammarPool *const""'");
+ }
+ arg3 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLGrammarPool * >(argp3);
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::SAXParser *)new XERCES_CPP_NAMESPACE::SAXParser(arg1,arg2,arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_SAXParser__SWIG_1) {
+ {
+ 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::SAXParser *result = 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: new_SAXParser(valToAdopt,manager);");
+ }
+ {
+ if (ST(0) != &PL_sv_undef) {
+ int rc = SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator, SWIG_POINTER_DISOWN | 0);
+ if (!SWIG_IsOK(rc)) {
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "new_SAXParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::XMLValidator *const""'");
+ }
+ }
+ }
+ 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_SAXParser" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp2);
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::SAXParser *)new XERCES_CPP_NAMESPACE::SAXParser(arg1,arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_SAXParser__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_SAXParser();");
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::SAXParser *)new XERCES_CPP_NAMESPACE::SAXParser();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_SAXParser) {
+ 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) && (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__XMLValidator, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _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_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_SAXParser__SWIG_2); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_SAXParser__SWIG_1); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_SAXParser__SWIG_0); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_SAXParser'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_SAXParser) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_SAXParser(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SAXParser" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_getDocumentHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XERCES_CPP_NAMESPACE::DocumentHandler *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getDocumentHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getDocumentHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DocumentHandler *)(arg1)->getDocumentHandler();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_getEntityResolver) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_getEntityResolver(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::EntityResolver *)(arg1)->getEntityResolver();
+ }
+ CATCH_XML_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_SAXParser_getXMLEntityResolver) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_getXMLEntityResolver(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getXMLEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLEntityResolver *)(arg1)->getXMLEntityResolver();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLEntityResolver, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_getErrorHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_getErrorHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::ErrorHandler *)(arg1)->getErrorHandler();
+ }
+ CATCH_XML_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_SAXParser_getPSVIHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_getPSVIHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getPSVIHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::PSVIHandler *)(arg1)->getPSVIHandler();
+ }
+ CATCH_XML_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_SAXParser_getValidator) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_getValidator(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getValidator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ {
+ XERCES_CPP_NAMESPACE::XMLValidator const &_result_ref = ((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getValidator();
+ result = (XERCES_CPP_NAMESPACE::XMLValidator *) &_result_ref;
+ }
+ }
+ CATCH_XML_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_SAXParser_getValidationScheme) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParser::ValSchemes result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getValidationScheme(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getValidationScheme" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::SAXParser::ValSchemes)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getValidationScheme();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_getDoSchema) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getDoSchema(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getDoSchema" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getDoSchema();
+ }
+ 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_SAXParser_getValidationSchemaFullChecking) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getValidationSchemaFullChecking(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getValidationSchemaFullChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getValidationSchemaFullChecking();
+ }
+ 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_SAXParser_getIdentityConstraintChecking) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getIdentityConstraintChecking(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getIdentityConstraintChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getIdentityConstraintChecking();
+ }
+ 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_SAXParser_getErrorCount) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getErrorCount(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getErrorCount" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (int)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getErrorCount();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_getDoNamespaces) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getDoNamespaces(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getDoNamespaces" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getDoNamespaces();
+ }
+ 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_SAXParser_getExitOnFirstFatalError) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getExitOnFirstFatalError(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getExitOnFirstFatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getExitOnFirstFatalError();
+ }
+ 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_SAXParser_getValidationConstraintFatal) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getValidationConstraintFatal(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getValidationConstraintFatal" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getValidationConstraintFatal();
+ }
+ 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_SAXParser_getExternalSchemaLocation) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getExternalSchemaLocation(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getExternalSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getExternalSchemaLocation();
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_getExternalNoNamespaceSchemaLocation) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XMLCh *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getExternalNoNamespaceSchemaLocation(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getExternalNoNamespaceSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getExternalNoNamespaceSchemaLocation();
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(result);
+ ++argvi;
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_getSecurityManager) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XERCES_CPP_NAMESPACE::SecurityManager *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getSecurityManager(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getSecurityManager" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::SecurityManager *)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getSecurityManager();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SecurityManager, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_getLoadExternalDTD) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getLoadExternalDTD(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getLoadExternalDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getLoadExternalDTD();
+ }
+ 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_SAXParser_isCachingGrammarFromParse) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_isCachingGrammarFromParse(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_isCachingGrammarFromParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->isCachingGrammarFromParse();
+ }
+ 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_SAXParser_isUsingCachedGrammarInParse) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_isUsingCachedGrammarInParse(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_isUsingCachedGrammarInParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->isUsingCachedGrammarInParse();
+ }
+ 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_SAXParser_getCalculateSrcOfs) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getCalculateSrcOfs(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getCalculateSrcOfs" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getCalculateSrcOfs();
+ }
+ 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_SAXParser_getStandardUriConformant) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getStandardUriConformant(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getStandardUriConformant" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getStandardUriConformant();
+ }
+ 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_SAXParser_getGrammar) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_getGrammar(self,nameSpaceKey);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getGrammar((XMLCh const *)arg2);
+ }
+ 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;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_getRootGrammar) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_getRootGrammar(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getRootGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getRootGrammar();
+ }
+ 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_SAXParser_getURIText) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_getURIText(self,uriId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getURIText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_getURIText" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getURIText(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(result);
+ ++argvi;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_getSrcOffset) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ unsigned int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getSrcOffset(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getSrcOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (unsigned int)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getSrcOffset();
+ }
+ CATCH_XML_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_SAXParser_getGenerateSyntheticAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getGenerateSyntheticAnnotations(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getGenerateSyntheticAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getGenerateSyntheticAnnotations();
+ }
+ 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_SAXParser_getValidateAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getValidateAnnotations(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getValidateAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getValidateAnnotations();
+ }
+ 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_SAXParser_getIgnoreCachedDTD) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getIgnoreCachedDTD(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getIgnoreCachedDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getIgnoreCachedDTD();
+ }
+ 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_SAXParser_getIgnoreAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getIgnoreAnnotations(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getIgnoreAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getIgnoreAnnotations();
+ }
+ 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_SAXParser_getDisableDefaultEntityResolution) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getDisableDefaultEntityResolution(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getDisableDefaultEntityResolution" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getDisableDefaultEntityResolution();
+ }
+ 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_SAXParser_getSkipDTDValidation) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_getSkipDTDValidation(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_getSkipDTDValidation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAXParser const *)arg1)->getSkipDTDValidation();
+ }
+ 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_SAXParser_setGenerateSyntheticAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setGenerateSyntheticAnnotations(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setGenerateSyntheticAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setGenerateSyntheticAnnotations" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setGenerateSyntheticAnnotations(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setValidateAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setValidateAnnotations(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setValidateAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setValidateAnnotations" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setValidateAnnotations(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setDoNamespaces) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setDoNamespaces(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setDoNamespaces" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setDoNamespaces" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setDoNamespaces(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setValidationScheme) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XERCES_CPP_NAMESPACE::SAXParser::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: SAXParser_setValidationScheme(self,newScheme);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setValidationScheme" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setValidationScheme" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SAXParser::ValSchemes""'");
+ }
+ arg2 = static_cast< XERCES_CPP_NAMESPACE::SAXParser::ValSchemes >(val2);
+ {
+ try
+ {
+ (arg1)->setValidationScheme(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setDoSchema) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setDoSchema(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setDoSchema" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setDoSchema" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setDoSchema(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setValidationSchemaFullChecking) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setValidationSchemaFullChecking(self,schemaFullChecking);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setValidationSchemaFullChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setValidationSchemaFullChecking" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setValidationSchemaFullChecking(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setIdentityConstraintChecking) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setIdentityConstraintChecking(self,identityConstraintChecking);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setIdentityConstraintChecking" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setIdentityConstraintChecking" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setIdentityConstraintChecking(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setExitOnFirstFatalError) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setExitOnFirstFatalError(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setExitOnFirstFatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setExitOnFirstFatalError" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setExitOnFirstFatalError(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setValidationConstraintFatal) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setValidationConstraintFatal(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setValidationConstraintFatal" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setValidationConstraintFatal" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setValidationConstraintFatal(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setExternalSchemaLocation) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SAXParser_setExternalSchemaLocation(self,schemaLocation);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setExternalSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->setExternalSchemaLocation((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setExternalNoNamespaceSchemaLocation) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SAXParser_setExternalNoNamespaceSchemaLocation(self,noNamespaceSchemaLocation);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setExternalNoNamespaceSchemaLocation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->setExternalNoNamespaceSchemaLocation((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setSecurityManager) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XERCES_CPP_NAMESPACE::SecurityManager *arg2 = (XERCES_CPP_NAMESPACE::SecurityManager *) (XERCES_CPP_NAMESPACE::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: SAXParser_setSecurityManager(self,securityManager);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setSecurityManager" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SecurityManager, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAXParser_setSecurityManager" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::SecurityManager *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::SecurityManager * >(argp2);
+ {
+ try
+ {
+ (arg1)->setSecurityManager(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setLoadExternalDTD) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setLoadExternalDTD(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setLoadExternalDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setLoadExternalDTD" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setLoadExternalDTD(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_cacheGrammarFromParse) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_cacheGrammarFromParse(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_cacheGrammarFromParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_cacheGrammarFromParse" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->cacheGrammarFromParse(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_useCachedGrammarInParse) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_useCachedGrammarInParse(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_useCachedGrammarInParse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_useCachedGrammarInParse" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->useCachedGrammarInParse(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setCalculateSrcOfs) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setCalculateSrcOfs(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setCalculateSrcOfs" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setCalculateSrcOfs" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setCalculateSrcOfs(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setStandardUriConformant) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setStandardUriConformant(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setStandardUriConformant" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setStandardUriConformant" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setStandardUriConformant(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_useScanner) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SAXParser_useScanner(self,scannerName);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_useScanner" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->useScanner((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setInputBufferSize) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ size_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SAXParser_setInputBufferSize(self,bufferSize);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setInputBufferSize" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setInputBufferSize" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = static_cast< size_t >(val2);
+ {
+ try
+ {
+ (arg1)->setInputBufferSize(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setIgnoreCachedDTD) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setIgnoreCachedDTD(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setIgnoreCachedDTD" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setIgnoreCachedDTD" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setIgnoreCachedDTD(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setIgnoreAnnotations) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setIgnoreAnnotations(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setIgnoreAnnotations" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setIgnoreAnnotations" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setIgnoreAnnotations(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setDisableDefaultEntityResolution) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setDisableDefaultEntityResolution(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setDisableDefaultEntityResolution" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setDisableDefaultEntityResolution" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setDisableDefaultEntityResolution(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setSkipDTDValidation) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setSkipDTDValidation(self,newValue);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setSkipDTDValidation" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setSkipDTDValidation" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setSkipDTDValidation(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_installAdvDocHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLDocumentHandler *arg2 = (XERCES_CPP_NAMESPACE::XMLDocumentHandler *) (XERCES_CPP_NAMESPACE::XMLDocumentHandler *)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: SAXParser_installAdvDocHandler(self,toInstall);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_installAdvDocHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDocumentHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAXParser_installAdvDocHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLDocumentHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLDocumentHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->installAdvDocHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_removeAdvDocHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLDocumentHandler *arg2 = (XERCES_CPP_NAMESPACE::XMLDocumentHandler *) (XERCES_CPP_NAMESPACE::XMLDocumentHandler *)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: SAXParser_removeAdvDocHandler(self,toRemove);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_removeAdvDocHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDocumentHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAXParser_removeAdvDocHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLDocumentHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLDocumentHandler * >(argp2);
+ {
+ try
+ {
+ result = (bool)(arg1)->removeAdvDocHandler(arg2);
+ }
+ 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_SAXParser_parseFirst__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_parseFirst(self,systemId,toFill);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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 '" "SAXParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAXParser_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_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_SAXParser_parseFirst__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_parseFirst(self,systemId,toFill);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAXParser_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 '" "SAXParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAXParser_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_XML_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_SAXParser_parseFirst__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_parseFirst(self,source,toFill);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_parseFirst" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAXParser_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 '" "SAXParser_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAXParser_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_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_SAXParser_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__SAXParser, 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__SAXParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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__SAXParser, 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_SAXParser_parseFirst__SWIG_2); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAXParser_parseFirst__SWIG_0); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAXParser_parseFirst__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'SAXParser_parseFirst'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_SAXParser_parseNext) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_parseNext(self,token);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_parseNext" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_parseNext" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAXParser_parseNext" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp2);
+ {
+ try
+ {
+ result = (bool)(arg1)->parseNext(*arg2);
+ }
+ 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_SAXParser_parseReset) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_parseReset(self,token);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_parseReset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_parseReset" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAXParser_parseReset" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp2);
+ {
+ try
+ {
+ (arg1)->parseReset(*arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_loadGrammar__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_loadGrammar(self,source,grammarType,toCache);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAXParser_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 '" "SAXParser_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 '" "SAXParser_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_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_SAXParser_loadGrammar__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_loadGrammar(self,source,grammarType);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAXParser_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 '" "SAXParser_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_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_SAXParser_loadGrammar__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_loadGrammar(self,systemId,grammarType,toCache);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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 '" "SAXParser_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 '" "SAXParser_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_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;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_loadGrammar__SWIG_3) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_loadGrammar(self,systemId,grammarType);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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 '" "SAXParser_loadGrammar" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = static_cast< short >(val3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3);
+ }
+ 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;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_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__SAXParser, 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__SAXParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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__SAXParser, 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__SAXParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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_SAXParser_loadGrammar__SWIG_1); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAXParser_loadGrammar__SWIG_3); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAXParser_loadGrammar__SWIG_0); return;
+ case 4:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAXParser_loadGrammar__SWIG_2); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'SAXParser_loadGrammar'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_SAXParser_resetCachedGrammarPool) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_resetCachedGrammarPool(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_resetCachedGrammarPool" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ (arg1)->resetCachedGrammarPool();
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_parse__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_parse(self,source);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_parse" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAXParser_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_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_parse__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SAXParser_parse(self,systemId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->parse((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_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__SAXParser, 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__SAXParser, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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_SAXParser_parse__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAXParser_parse__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'SAXParser_parse'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_SAXParser_setDocumentHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XERCES_CPP_NAMESPACE::DocumentHandler *arg2 = (XERCES_CPP_NAMESPACE::DocumentHandler *) (XERCES_CPP_NAMESPACE::DocumentHandler *)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: SAXParser_setDocumentHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setDocumentHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAXParser_setDocumentHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DocumentHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DocumentHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setDocumentHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setDTDHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ XERCES_CPP_NAMESPACE::DTDHandler *arg2 = (XERCES_CPP_NAMESPACE::DTDHandler *) (XERCES_CPP_NAMESPACE::DTDHandler *)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: SAXParser_setDTDHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setDTDHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAXParser_setDTDHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DTDHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DTDHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setDTDHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setErrorHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setErrorHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setErrorHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setErrorHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setPSVIHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setPSVIHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setPSVIHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setPSVIHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::PSVIHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::PSVIHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setPSVIHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setEntityResolver) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setEntityResolver(self,resolver);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setEntityResolver" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::EntityResolver *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::EntityResolver * >(argp2);
+ {
+ try
+ {
+ (arg1)->setEntityResolver(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_setXMLEntityResolver) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_setXMLEntityResolver(self,resolver);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_setXMLEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_setXMLEntityResolver" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLEntityResolver *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLEntityResolver * >(argp2);
+ {
+ try
+ {
+ (arg1)->setXMLEntityResolver(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAXParser_error) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 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: SAXParser_error(self,errCode,msgDomain,errType,errorText,systemId,publicId,lineNum,colNum);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_error" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(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 '" "SAXParser_error" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(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 '" "SAXParser_error" "', argument " "4"" of type '" "XMLErrorReporter::ErrTypes const""'");
+ }
+ if (!argp4) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAXParser_error" "', argument " "4"" of type '" "XMLErrorReporter::ErrTypes const""'");
+ } else {
+ arg4 = *(reinterpret_cast< XMLErrorReporter::ErrTypes * >(argp4));
+ }
+ }
+
+ // we convert *everything* into a string *including* undef
+ arg5 = UTF8_TRANSCODER->Local2XMLString(ST(4));
+
+
+ // we convert *everything* into a string *including* undef
+ arg6 = UTF8_TRANSCODER->Local2XMLString(ST(5));
+
+
+ // we convert *everything* into a string *including* undef
+ arg7 = UTF8_TRANSCODER->Local2XMLString(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 '" "SAXParser_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 '" "SAXParser_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_XML_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_SAXParser_resetErrors) {
+ {
+ XERCES_CPP_NAMESPACE::SAXParser *arg1 = (XERCES_CPP_NAMESPACE::SAXParser *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAXParser_resetErrors(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAXParser_resetErrors" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAXParser *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAXParser * >(argp1);
+ {
+ try
+ {
+ (arg1)->resetErrors();
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_delete_SAX2XMLReader) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_SAX2XMLReader(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SAX2XMLReader" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_getContentHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XERCES_CPP_NAMESPACE::ContentHandler *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAX2XMLReader_getContentHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getContentHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::ContentHandler *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getContentHandler();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_getDTDHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XERCES_CPP_NAMESPACE::DTDHandler *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAX2XMLReader_getDTDHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getDTDHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DTDHandler *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getDTDHandler();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_getFeature) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SAX2XMLReader_getFeature(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getFeature" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getFeature((XMLCh const *)arg2);
+ }
+ CATCH_SAX_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_SAX2XMLReader_getProperty) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SAX2XMLReader_getProperty(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getProperty" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try {
+ result = (void *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getProperty((XMLCh const *)arg2);
+ }
+ CATCH_SAX_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_SAX2XMLReader_setContentHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XERCES_CPP_NAMESPACE::ContentHandler *arg2 = (XERCES_CPP_NAMESPACE::ContentHandler *) (XERCES_CPP_NAMESPACE::ContentHandler *)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: SAX2XMLReader_setContentHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setContentHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAX2XMLReader_setContentHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::ContentHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::ContentHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setContentHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_setDTDHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XERCES_CPP_NAMESPACE::DTDHandler *arg2 = (XERCES_CPP_NAMESPACE::DTDHandler *) (XERCES_CPP_NAMESPACE::DTDHandler *)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: SAX2XMLReader_setDTDHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setDTDHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DTDHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAX2XMLReader_setDTDHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DTDHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DTDHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setDTDHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_setEntityResolver) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_setEntityResolver(self,resolver);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setEntityResolver" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_setEntityResolver" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::EntityResolver *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::EntityResolver * >(argp2);
+ {
+ try
+ {
+ (arg1)->setEntityResolver(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_setErrorHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_setErrorHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setErrorHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_setErrorHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::ErrorHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::ErrorHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setErrorHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_setFeature) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (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: SAX2XMLReader_setFeature(self,name,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setFeature" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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 '" "SAX2XMLReader_setFeature" "', argument " "3"" of type '" "bool""'");
+ }
+ arg3 = static_cast< bool >(val3);
+ {
+ try {
+ (arg1)->setFeature((XMLCh const *)arg2,arg3);
+ }
+ CATCH_SAX_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_setProperty) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *arg3 = (void *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3)) {
+ SWIG_croak("Usage: SAX2XMLReader_setProperty(self,name,value);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setProperty" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+ }
+ {
+ if (XMLString::compareIStringASCII(arg2, XMLUni::fgXercesSecurityManager) == 0) {
+ makeSAXNotSupportedException(SAXNotSupportedException("Setting security manager not supported"));
+ goto fail;
+ }
+ }
+ {
+ try {
+ (arg1)->setProperty((XMLCh const *)arg2,arg3);
+ }
+ CATCH_SAX_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_parse__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_parse(self,source);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_parse" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAX2XMLReader_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_SAX_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_parse__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SAX2XMLReader_parse(self,systemId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_parse" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try {
+ (arg1)->parse((XMLCh const *)arg2);
+ }
+ CATCH_SAX_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_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__SAX2XMLReader, 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__SAX2XMLReader, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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_SAX2XMLReader_parse__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAX2XMLReader_parse__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'SAX2XMLReader_parse'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_SAX2XMLReader_getDeclarationHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XERCES_CPP_NAMESPACE::DeclHandler *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAX2XMLReader_getDeclarationHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getDeclarationHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::DeclHandler *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getDeclarationHandler();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_getLexicalHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XERCES_CPP_NAMESPACE::LexicalHandler *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAX2XMLReader_getLexicalHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getLexicalHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::LexicalHandler *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getLexicalHandler();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_setDeclarationHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XERCES_CPP_NAMESPACE::DeclHandler *arg2 = (XERCES_CPP_NAMESPACE::DeclHandler *) (XERCES_CPP_NAMESPACE::DeclHandler *)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: SAX2XMLReader_setDeclarationHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setDeclarationHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAX2XMLReader_setDeclarationHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::DeclHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::DeclHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setDeclarationHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_setLexicalHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XERCES_CPP_NAMESPACE::LexicalHandler *arg2 = (XERCES_CPP_NAMESPACE::LexicalHandler *) (XERCES_CPP_NAMESPACE::LexicalHandler *)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: SAX2XMLReader_setLexicalHandler(self,handler);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setLexicalHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAX2XMLReader_setLexicalHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::LexicalHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::LexicalHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->setLexicalHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_getValidator) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_getValidator(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getValidator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::XMLValidator *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getValidator();
+ }
+ CATCH_XML_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_SAX2XMLReader_getErrorCount) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAX2XMLReader_getErrorCount(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getErrorCount" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ result = (int)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getErrorCount();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_getExitOnFirstFatalError) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAX2XMLReader_getExitOnFirstFatalError(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getExitOnFirstFatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getExitOnFirstFatalError();
+ }
+ 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_SAX2XMLReader_getValidationConstraintFatal) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAX2XMLReader_getValidationConstraintFatal(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getValidationConstraintFatal" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ result = (bool)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getValidationConstraintFatal();
+ }
+ 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_SAX2XMLReader_getGrammar) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_getGrammar(self,nameSpaceKey);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getGrammar((XMLCh const *)arg2);
+ }
+ 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;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_getRootGrammar) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_getRootGrammar(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getRootGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->getRootGrammar();
+ }
+ 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_SAX2XMLReader_getURIText) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_getURIText(self,uriId);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getURIText" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_getURIText" "', argument " "2"" of type '" "unsigned int""'");
+ }
+ arg2 = static_cast< unsigned int >(val2);
+ {
+ try
+ {
+ result = (XMLCh *)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getURIText(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+ ST(argvi) = UTF8_TRANSCODER->XMLString2Local(result);
+ ++argvi;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_getSrcOffset) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ unsigned int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAX2XMLReader_getSrcOffset(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_getSrcOffset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader const *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ result = (unsigned int)((XERCES_CPP_NAMESPACE::SAX2XMLReader const *)arg1)->getSrcOffset();
+ }
+ CATCH_XML_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_SAX2XMLReader_setValidator) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLValidator *arg2 = (XERCES_CPP_NAMESPACE::XMLValidator *) 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: SAX2XMLReader_setValidator(self,valueToAdopt);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setValidator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLValidator, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAX2XMLReader_setValidator" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLValidator *""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLValidator * >(argp2);
+ {
+ try
+ {
+ (arg1)->setValidator(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_setExitOnFirstFatalError) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_setExitOnFirstFatalError(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setExitOnFirstFatalError" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_setExitOnFirstFatalError" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setExitOnFirstFatalError(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_setValidationConstraintFatal) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_setValidationConstraintFatal(self,newState);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setValidationConstraintFatal" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_setValidationConstraintFatal" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = static_cast< bool >(val2);
+ {
+ try
+ {
+ (arg1)->setValidationConstraintFatal(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_parseFirst__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_parseFirst(self,systemId,toFill);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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 '" "SAX2XMLReader_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAX2XMLReader_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_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_SAX2XMLReader_parseFirst__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_parseFirst(self,systemId,toFill);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAX2XMLReader_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 '" "SAX2XMLReader_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAX2XMLReader_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_XML_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_SAX2XMLReader_parseFirst__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_parseFirst(self,source,toFill);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_parseFirst" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_parseFirst" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAX2XMLReader_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 '" "SAX2XMLReader_parseFirst" "', argument " "3"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAX2XMLReader_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_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_SAX2XMLReader_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__SAX2XMLReader, 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__SAX2XMLReader, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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__SAX2XMLReader, 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_SAX2XMLReader_parseFirst__SWIG_2); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAX2XMLReader_parseFirst__SWIG_0); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAX2XMLReader_parseFirst__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'SAX2XMLReader_parseFirst'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_SAX2XMLReader_parseNext) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_parseNext(self,token);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_parseNext" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_parseNext" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAX2XMLReader_parseNext" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp2);
+ {
+ try
+ {
+ result = (bool)(arg1)->parseNext(*arg2);
+ }
+ 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_SAX2XMLReader_parseReset) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_parseReset(self,token);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_parseReset" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_parseReset" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAX2XMLReader_parseReset" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLPScanToken &""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLPScanToken * >(argp2);
+ {
+ try
+ {
+ (arg1)->parseReset(*arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_loadGrammar__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_loadGrammar(self,source,grammarType,toCache);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAX2XMLReader_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 '" "SAX2XMLReader_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 '" "SAX2XMLReader_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_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_SAX2XMLReader_loadGrammar__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_loadGrammar(self,source,grammarType);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_loadGrammar" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::InputSource const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SAX2XMLReader_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 '" "SAX2XMLReader_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_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_SAX2XMLReader_loadGrammar__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_loadGrammar(self,systemId,grammarType,toCache);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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 '" "SAX2XMLReader_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 '" "SAX2XMLReader_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_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;
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_loadGrammar__SWIG_3) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 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: SAX2XMLReader_loadGrammar(self,systemId,grammarType);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_loadGrammar" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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 '" "SAX2XMLReader_loadGrammar" "', argument " "3"" of type '" "short""'");
+ }
+ arg3 = static_cast< short >(val3);
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::Grammar *)(arg1)->loadGrammar((XMLCh const *)arg2,arg3);
+ }
+ 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;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_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__SAX2XMLReader, 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__SAX2XMLReader, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_2;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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__SAX2XMLReader, 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__SAX2XMLReader, 0);
+ _v = SWIG_CheckState(res);
+ }
+ if (!_v) goto check_4;
+ _ranki += _v*_pi;
+ _rankm += _pi;
+ _pi *= SWIG_MAXCASTRANK;
+ {
+ {
+ _v = 1;
+ }
+ }
+ 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_SAX2XMLReader_loadGrammar__SWIG_1); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAX2XMLReader_loadGrammar__SWIG_3); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAX2XMLReader_loadGrammar__SWIG_0); return;
+ case 4:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_SAX2XMLReader_loadGrammar__SWIG_2); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'SAX2XMLReader_loadGrammar'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_SAX2XMLReader_resetCachedGrammarPool) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: SAX2XMLReader_resetCachedGrammarPool(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_resetCachedGrammarPool" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ {
+ try
+ {
+ (arg1)->resetCachedGrammarPool();
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_setInputBufferSize) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ size_t arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: SAX2XMLReader_setInputBufferSize(self,bufferSize);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_setInputBufferSize" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(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 '" "SAX2XMLReader_setInputBufferSize" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = static_cast< size_t >(val2);
+ {
+ try
+ {
+ (arg1)->setInputBufferSize(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_installAdvDocHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLDocumentHandler *arg2 = (XERCES_CPP_NAMESPACE::XMLDocumentHandler *) (XERCES_CPP_NAMESPACE::XMLDocumentHandler *)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: SAX2XMLReader_installAdvDocHandler(self,toInstall);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_installAdvDocHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDocumentHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAX2XMLReader_installAdvDocHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLDocumentHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLDocumentHandler * >(argp2);
+ {
+ try
+ {
+ (arg1)->installAdvDocHandler(arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_SAX2XMLReader_removeAdvDocHandler) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *arg1 = (XERCES_CPP_NAMESPACE::SAX2XMLReader *) 0 ;
+ XERCES_CPP_NAMESPACE::XMLDocumentHandler *arg2 = (XERCES_CPP_NAMESPACE::XMLDocumentHandler *) (XERCES_CPP_NAMESPACE::XMLDocumentHandler *)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: SAX2XMLReader_removeAdvDocHandler(self,toRemove);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SAX2XMLReader_removeAdvDocHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::SAX2XMLReader *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::SAX2XMLReader * >(argp1);
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLDocumentHandler, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SAX2XMLReader_removeAdvDocHandler" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLDocumentHandler *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLDocumentHandler * >(argp2);
+ {
+ try
+ {
+ result = (bool)(arg1)->removeAdvDocHandler(arg2);
+ }
+ 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_XMLReaderFactory_createXMLReader__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::MemoryManager *arg1 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
+ XERCES_CPP_NAMESPACE::XMLGrammarPool *arg2 = (XERCES_CPP_NAMESPACE::XMLGrammarPool *) (XERCES_CPP_NAMESPACE::XMLGrammarPool *)0 ;
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ arg1 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
+ if ((items < 0) || (items > 2)) {
+ SWIG_croak("Usage: XMLReaderFactory_createXMLReader(manager,gramPool);");
+ }
+ if (items > 0) {
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLReaderFactory_createXMLReader" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp1);
+ }
+ if (items > 1) {
+ res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarPool, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLReaderFactory_createXMLReader" "', argument " "2"" of type '" "XERCES_CPP_NAMESPACE::XMLGrammarPool *const""'");
+ }
+ arg2 = reinterpret_cast< XERCES_CPP_NAMESPACE::XMLGrammarPool * >(argp2);
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::SAX2XMLReader *)XERCES_CPP_NAMESPACE::XMLReaderFactory::createXMLReader(arg1,arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLReaderFactory_createXMLReader__SWIG_1) {
+ {
+ XERCES_CPP_NAMESPACE::MemoryManager *arg1 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ arg1 = XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager;
+ if ((items < 0) || (items > 1)) {
+ SWIG_croak("Usage: XMLReaderFactory_createXMLReader(manager);");
+ }
+ if (items > 0) {
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLReaderFactory_createXMLReader" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::MemoryManager *const""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::MemoryManager * >(argp1);
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::SAX2XMLReader *)XERCES_CPP_NAMESPACE::XMLReaderFactory::createXMLReader(arg1);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLReaderFactory_createXMLReader__SWIG_2) {
+ {
+ XERCES_CPP_NAMESPACE::SAX2XMLReader *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: XMLReaderFactory_createXMLReader();");
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::SAX2XMLReader *)XERCES_CPP_NAMESPACE::XMLReaderFactory::createXMLReader();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAX2XMLReader, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_XMLReaderFactory_createXMLReader) {
+ dXSARGS;
+
+ {
+ unsigned long _index = 0;
+ SWIG_TypeRank _rank = 0;
+ if ((items >= 0) && (items <= 2)) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ if (items > 0) {
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &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 > 1) {
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(1), &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 >= 0) && (items <= 1)) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ SWIG_TypeRank _pi = 1;
+ int _v = 0;
+ if (items > 0) {
+ {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(ST(0), &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 == 0) {
+ SWIG_TypeRank _ranki = 0;
+ SWIG_TypeRank _rankm = 0;
+ if (!_index || (_ranki < _rank)) {
+ _rank = _ranki; _index = 3;
+ if (_rank == _rankm) goto dispatch;
+ }
+ }
+ dispatch:
+ switch(_index) {
+ case 1:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XMLReaderFactory_createXMLReader__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XMLReaderFactory_createXMLReader__SWIG_1); return;
+ case 3:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_XMLReaderFactory_createXMLReader__SWIG_2); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'XMLReaderFactory_createXMLReader'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_new_PerlSAXCallbackHandler__SWIG_0) {
+ {
+ XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0)) {
+ SWIG_croak("Usage: new_PerlSAXCallbackHandler();");
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *)new XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+ XSRETURN(argvi);
+ fail:
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_PerlSAXCallbackHandler__SWIG_1) {
+ {
+ SV *arg1 = (SV *) 0 ;
+ XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *result = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: new_PerlSAXCallbackHandler(obj);");
+ }
+ {
+ arg1 = ST(0);
+ }
+ {
+ try
+ {
+ result = (XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *)new XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler(arg1);
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_new_PerlSAXCallbackHandler) {
+ 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 = 1;
+ }
+ }
+ 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_PerlSAXCallbackHandler__SWIG_0); return;
+ case 2:
+ ++PL_markstack_ptr; SWIG_CALLXS(_wrap_new_PerlSAXCallbackHandler__SWIG_1); return;
+ }
+ }
+
+ croak("No matching function for overloaded 'new_PerlSAXCallbackHandler'");
+ XSRETURN(0);
+}
+
+
+XS(_wrap_delete_PerlSAXCallbackHandler) {
+ {
+ XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *arg1 = (XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: delete_PerlSAXCallbackHandler(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PerlSAXCallbackHandler" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler * >(argp1);
+ {
+ try
+ {
+ delete arg1;
+
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PerlSAXCallbackHandler_type) {
+ {
+ XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *arg1 = (XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *) 0 ;
+ int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1)) {
+ SWIG_croak("Usage: PerlSAXCallbackHandler_type(self);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlSAXCallbackHandler_type" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler * >(argp1);
+ {
+ try
+ {
+ result = (int)(arg1)->type();
+ }
+ CATCH_XML_EXCEPTION
+ }
+ ST(argvi) = SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(result)); argvi++ ;
+
+ XSRETURN(argvi);
+ fail:
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PerlSAXCallbackHandler_characters) {
+ {
+ XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *arg1 = (XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *) 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: PerlSAXCallbackHandler_characters(self,chars,length);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlSAXCallbackHandler_characters" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(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 '" "PerlSAXCallbackHandler_characters" "', argument " "3"" of type '" "unsigned int""'");
+ }
+ arg3 = static_cast< unsigned int >(val3);
+ {
+ try
+ {
+ (arg1)->characters((XMLCh const *)arg2,arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PerlSAXCallbackHandler_processingInstruction) {
+ {
+ XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *arg1 = (XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *) 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: PerlSAXCallbackHandler_processingInstruction(self,target,data);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlSAXCallbackHandler_processingInstruction" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+ {
+ try
+ {
+ (arg1)->processingInstruction((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PerlSAXCallbackHandler_setDocumentLocator) {
+ {
+ XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *arg1 = (XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *) 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: PerlSAXCallbackHandler_setDocumentLocator(self,locator);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlSAXCallbackHandler_setDocumentLocator" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler * >(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 '" "PerlSAXCallbackHandler_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_XML_EXCEPTION
+ }
+
+
+
+ XSRETURN(argvi);
+ fail:
+
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PerlSAXCallbackHandler_startPrefixMapping) {
+ {
+ XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *arg1 = (XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *) 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: PerlSAXCallbackHandler_startPrefixMapping(self,prefix,uri);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlSAXCallbackHandler_startPrefixMapping" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+
+ // we convert *everything* into a string *including* undef
+ arg3 = UTF8_TRANSCODER->Local2XMLString(ST(2));
+
+ {
+ try
+ {
+ (arg1)->startPrefixMapping((XMLCh const *)arg2,(XMLCh const *)arg3);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+
+ delete[] arg3;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PerlSAXCallbackHandler_endPrefixMapping) {
+ {
+ XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *arg1 = (XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: PerlSAXCallbackHandler_endPrefixMapping(self,prefix);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlSAXCallbackHandler_endPrefixMapping" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->endPrefixMapping((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+XS(_wrap_PerlSAXCallbackHandler_skippedEntity) {
+ {
+ XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *arg1 = (XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *) 0 ;
+ XMLCh *arg2 = (XMLCh *) (XMLCh *)0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2)) {
+ SWIG_croak("Usage: PerlSAXCallbackHandler_skippedEntity(self,name);");
+ }
+ res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PerlSAXCallbackHandler_skippedEntity" "', argument " "1"" of type '" "XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *""'");
+ }
+ arg1 = reinterpret_cast< XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler * >(argp1);
+
+ // we convert *everything* into a string *including* undef
+ arg2 = UTF8_TRANSCODER->Local2XMLString(ST(1));
+
+ {
+ try
+ {
+ (arg1)->skippedEntity((XMLCh const *)arg2);
+ }
+ CATCH_XML_EXCEPTION
+ }
+
+
+
+ delete[] arg2;
+
+ XSRETURN(argvi);
+ fail:
+
+
+ delete[] arg2;
+
+ SWIG_croak_null();
+ }
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+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 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__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__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__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__DocumentHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DocumentHandler *) ((XERCES_CPP_NAMESPACE::HandlerBase *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__DocumentHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::DocumentHandler *) ((XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *) 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__PerlErrorCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__ErrorHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::ErrorHandler *) ((XERCES_CPP_NAMESPACE::PerlErrorCallbackHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XERCES_CPP_NAMESPACE__XMLDocumentHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLDocumentHandler *) ((XERCES_CPP_NAMESPACE::SAXParser *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__ContentHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::ContentHandler *) ((XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__PerlErrorCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__PerlCallbackHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::PerlCallbackHandler *) ((XERCES_CPP_NAMESPACE::PerlErrorCallbackHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandlerTo_p_XERCES_CPP_NAMESPACE__PerlCallbackHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::PerlCallbackHandler *) ((XERCES_CPP_NAMESPACE::PerlEntityResolverHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__PerlCallbackHandler(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::PerlCallbackHandler *) ((XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandlerTo_p_XERCES_CPP_NAMESPACE__XMLEntityResolver(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMLEntityResolver *) ((XERCES_CPP_NAMESPACE::PerlEntityResolverHandler *) 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__PerlEntityResolverHandlerTo_p_XERCES_CPP_NAMESPACE__EntityResolver(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::EntityResolver *) ((XERCES_CPP_NAMESPACE::PerlEntityResolverHandler *) 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__XMLAttrTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::XMLAttr *) 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__RefArrayVectorOfTuint16_t_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::BaseRefVectorOf<XMLCh > *) ((XERCES_CPP_NAMESPACE::RefArrayVectorOf<uint16_t > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::BaseRefVectorOf<uint16_t > *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::BaseRefVectorOf<XERCES_CPP_NAMESPACE::XMLAttr > *) ((XERCES_CPP_NAMESPACE::RefVectorOf<XERCES_CPP_NAMESPACE::XMLAttr > *) 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__PSVIItemTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::PSVIItem *) 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__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__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__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__PSVIAttributeListTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::PSVIAttributeList *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__PSVIAttributeTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::PSVIItem *) ((XERCES_CPP_NAMESPACE::PSVIAttribute *) 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__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_tTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) ((XERCES_CPP_NAMESPACE::BaseRefVectorOf<XERCES_CPP_NAMESPACE::XMLAttr > *) 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__PSVIElementTo_p_XERCES_CPP_NAMESPACE__XMemory(void *x) {
+ return (void *)((XERCES_CPP_NAMESPACE::XMemory *) (XERCES_CPP_NAMESPACE::PSVIItem *) ((XERCES_CPP_NAMESPACE::PSVIElement *) x));
+}
+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__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__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__DTDHandler = {"_p_XERCES_CPP_NAMESPACE__DTDHandler", "XERCES_CPP_NAMESPACE::DTDHandler *", 0, 0, (void*)"XML::Xerces::DTDHandler", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DeclHandler = {"_p_XERCES_CPP_NAMESPACE__DeclHandler", "XERCES_CPP_NAMESPACE::DeclHandler *", 0, 0, (void*)"XML::Xerces::DeclHandler", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DocumentHandler = {"_p_XERCES_CPP_NAMESPACE__DocumentHandler", "XERCES_CPP_NAMESPACE::DocumentHandler *", 0, 0, (void*)"XML::Xerces::DocumentHandler", 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__PerlEntityResolverHandler = {"_p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandler", 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__PerlErrorCallbackHandler = {"_p_XERCES_CPP_NAMESPACE__PerlErrorCallbackHandler", 0, 0, 0, 0, 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__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__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__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__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__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__Parser = {"_p_XERCES_CPP_NAMESPACE__Parser", "XERCES_CPP_NAMESPACE::Parser *", 0, 0, (void*)"XML::Xerces::Parser", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__PerlCallbackHandler = {"_p_XERCES_CPP_NAMESPACE__PerlCallbackHandler", "XERCES_CPP_NAMESPACE::PerlCallbackHandler *", 0, 0, (void*)"XML::Xerces::PerlCallbackHandler", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler = {"_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler", "XERCES_CPP_NAMESPACE::PerlSAXCallbackHandler *", 0, 0, (void*)"XML::Xerces::PerlSAXCallbackHandler", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SAX2XMLReader = {"_p_XERCES_CPP_NAMESPACE__SAX2XMLReader", "XERCES_CPP_NAMESPACE::SAX2XMLReader *", 0, 0, (void*)"XML::Xerces::SAX2XMLReader", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SAXParseException = {"_p_XERCES_CPP_NAMESPACE__SAXParseException", "XERCES_CPP_NAMESPACE::SAXParseException *", 0, 0, (void*)"XML::Xerces::SAXParseException", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SAXParser = {"_p_XERCES_CPP_NAMESPACE__SAXParser", "XERCES_CPP_NAMESPACE::SAXParser *", 0, 0, (void*)"XML::Xerces::SAXParser", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__SecurityManager = {"_p_XERCES_CPP_NAMESPACE__SecurityManager", "XERCES_CPP_NAMESPACE::SecurityManager *", 0, 0, (void*)"XML::Xerces::SecurityManager", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLDocumentHandler = {"_p_XERCES_CPP_NAMESPACE__XMLDocumentHandler", "XERCES_CPP_NAMESPACE::XMLDocumentHandler *", 0, 0, (void*)"XML::Xerces::XMLDocumentHandler", 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLEntityResolver = {"_p_XERCES_CPP_NAMESPACE__XMLEntityResolver", "XERCES_CPP_NAMESPACE::XMLEntityResolver *", 0, 0, (void*)"XML::Xerces::XMLEntityResolver", 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__XMLReaderFactory = {"_p_XERCES_CPP_NAMESPACE__XMLReaderFactory", "XERCES_CPP_NAMESPACE::XMLReaderFactory *", 0, 0, (void*)"XML::Xerces::XMLReaderFactory", 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__XMLAttr = {"_p_XERCES_CPP_NAMESPACE__XMLAttr", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t = {"_p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t", 0, 0, 0, 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__DTDAttDef = {"_p_XERCES_CPP_NAMESPACE__DTDAttDef", 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__XMLNotationDecl = {"_p_XERCES_CPP_NAMESPACE__XMLNotationDecl", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__XMLFormatTarget = {"_p_XERCES_CPP_NAMESPACE__XMLFormatTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget = {"_p_XERCES_CPP_NAMESPACE__StdOutFormatTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget = {"_p_XERCES_CPP_NAMESPACE__LocalFileFormatTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__MemBufFormatTarget = {"_p_XERCES_CPP_NAMESPACE__MemBufFormatTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t = {"_p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__PSVIItem = {"_p_XERCES_CPP_NAMESPACE__PSVIItem", 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__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t = {"_p_XERCES_CPP_NAMESPACE__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_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__BaseRefVectorOfTuint16_t_t = {"_p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_t", 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__PSVIAttributeList = {"_p_XERCES_CPP_NAMESPACE__PSVIAttributeList", 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__PSVIAttribute = {"_p_XERCES_CPP_NAMESPACE__PSVIAttribute", 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__XMLFormatter = {"_p_XERCES_CPP_NAMESPACE__XMLFormatter", 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__PSVIElement = {"_p_XERCES_CPP_NAMESPACE__PSVIElement", 0, 0, 0, 0, 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_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__AttributeList,
+ &_swigt__p_XERCES_CPP_NAMESPACE__Attributes,
+ &_swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__ContentHandler,
+ &_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__DTDHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DTDValidator,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DeclHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__DocumentHandler,
+ &_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__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,
+ &_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__PSVIAttribute,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PSVIAttributeList,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PSVIElement,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PSVIHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PSVIItem,
+ &_swigt__p_XERCES_CPP_NAMESPACE__Parser,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PerlCallbackHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PerlErrorCallbackHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler,
+ &_swigt__p_XERCES_CPP_NAMESPACE__QName,
+ &_swigt__p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t,
+ &_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__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t,
+ &_swigt__p_XERCES_CPP_NAMESPACE__SAX2XMLReader,
+ &_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__SecurityManager,
+ &_swigt__p_XERCES_CPP_NAMESPACE__StdInInputSource,
+ &_swigt__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget,
+ &_swigt__p_XERCES_CPP_NAMESPACE__URLInputSource,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDef,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLAttDefList,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLAttr,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLContentModel,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLDTDDescription,
+ &_swigt__p_XERCES_CPP_NAMESPACE__XMLDocumentHandler,
+ &_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__XMLReaderFactory,
+ &_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_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_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__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__ContentHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__ContentHandler, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, _p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__ContentHandler, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DTDHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__HandlerBase, _p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__DTDHandler, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DTDHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DeclHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__DeclHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DocumentHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__HandlerBase, _p_XERCES_CPP_NAMESPACE__HandlerBaseTo_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__DocumentHandler, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, _p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__DocumentHandler, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandler[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandler, 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__PerlEntityResolverHandler, _p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandlerTo_p_XERCES_CPP_NAMESPACE__EntityResolver, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__PerlErrorCallbackHandler[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__PerlErrorCallbackHandler, 0, 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__PerlErrorCallbackHandler, _p_XERCES_CPP_NAMESPACE__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__HandlerBase[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__HandlerBase, 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__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},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__LexicalHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__LexicalHandler, 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__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__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__PerlCallbackHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__PerlCallbackHandler, 0, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__PerlErrorCallbackHandler, _p_XERCES_CPP_NAMESPACE__PerlErrorCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__PerlCallbackHandler, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandler, _p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandlerTo_p_XERCES_CPP_NAMESPACE__PerlCallbackHandler, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, _p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandlerTo_p_XERCES_CPP_NAMESPACE__PerlCallbackHandler, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SAX2XMLReader[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__SAX2XMLReader, 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__SAXParser[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__SAXParser, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__SecurityManager[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__SecurityManager, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMLDocumentHandler[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__SAXParser, _p_XERCES_CPP_NAMESPACE__SAXParserTo_p_XERCES_CPP_NAMESPACE__XMLDocumentHandler, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__XMLDocumentHandler, 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}, {&_swigt__p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandler, _p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandlerTo_p_XERCES_CPP_NAMESPACE__XMLEntityResolver, 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__XMLReaderFactory[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLReaderFactory, 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__XMLAttr[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttr, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t, 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__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__DTDAttDef[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__DTDAttDef, 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__XMLNotationDecl[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLNotationDecl, 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},{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__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__RefArrayVectorOfTuint16_t_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__PSVIItem[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__PSVIItem, 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__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_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__BaseRefVectorOfTuint16_t_t[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_t, 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__PSVIAttributeList[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__PSVIAttributeList, 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__PSVIAttribute[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__PSVIAttribute, 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__XMLFormatter[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__XMLFormatter, 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__PSVIElement[] = {{&_swigt__p_XERCES_CPP_NAMESPACE__PSVIElement, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__XMemory[] = { {&_swigt__p_XERCES_CPP_NAMESPACE__XMLAttr, _p_XERCES_CPP_NAMESPACE__XMLAttrTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t, _p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_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__DTDAttDef, _p_XERCES_CPP_NAMESPACE__DTDAttDefTo_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__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__RefArrayVectorOfTuint16_t_t, _p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_tTo_p_XERCES_CPP_NAMESPACE__XMemory, 0, 0}, {&_swigt__p_XERCES_CPP_NAMESPACE__PSVIItem, _p_XERCES_CPP_NAMESPACE__PSVIItemTo_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__InputSource, _p_XERCES_CPP_NAMESPACE__InputSourceTo_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__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__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t, _p_XERCES_CPP_NAMESPACE__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_tTo_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__BaseRefVectorOfTuint16_t_t, _p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_tTo_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__SchemaGrammar, _p_XERCES_CPP_NAMESPACE__SchemaGrammarTo_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__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__PSVIAttributeList, _p_XERCES_CPP_NAMESPACE__PSVIAttributeListTo_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__PSVIAttribute, _p_XERCES_CPP_NAMESPACE__PSVIAttributeTo_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__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}, {&_swigt__p_XERCES_CPP_NAMESPACE__PSVIElement, _p_XERCES_CPP_NAMESPACE__PSVIElementTo_p_XERCES_CPP_NAMESPACE__XMemory, 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_ValueVectorOfTXERCES_CPP_NAMESPACE__SchemaElementDecl_p_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__AttributeList,
+ _swigc__p_XERCES_CPP_NAMESPACE__Attributes,
+ _swigc__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__BaseRefVectorOfTuint16_t_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__ContentHandler,
+ _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__DTDHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__DTDValidator,
+ _swigc__p_XERCES_CPP_NAMESPACE__DeclHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__DocumentHandler,
+ _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__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,
+ _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__PSVIAttribute,
+ _swigc__p_XERCES_CPP_NAMESPACE__PSVIAttributeList,
+ _swigc__p_XERCES_CPP_NAMESPACE__PSVIElement,
+ _swigc__p_XERCES_CPP_NAMESPACE__PSVIHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__PSVIItem,
+ _swigc__p_XERCES_CPP_NAMESPACE__Parser,
+ _swigc__p_XERCES_CPP_NAMESPACE__PerlCallbackHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__PerlEntityResolverHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__PerlErrorCallbackHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler,
+ _swigc__p_XERCES_CPP_NAMESPACE__QName,
+ _swigc__p_XERCES_CPP_NAMESPACE__RefArrayVectorOfTuint16_t_t,
+ _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__RefVectorOfTXERCES_CPP_NAMESPACE__XMLAttr_t,
+ _swigc__p_XERCES_CPP_NAMESPACE__SAX2XMLReader,
+ _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__SecurityManager,
+ _swigc__p_XERCES_CPP_NAMESPACE__StdInInputSource,
+ _swigc__p_XERCES_CPP_NAMESPACE__StdOutFormatTarget,
+ _swigc__p_XERCES_CPP_NAMESPACE__URLInputSource,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLAttDef,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLAttDefList,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLAttr,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLContentModel,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLDTDDescription,
+ _swigc__p_XERCES_CPP_NAMESPACE__XMLDocumentHandler,
+ _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__XMLReaderFactory,
+ _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_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::delete_DTDHandler", _wrap_delete_DTDHandler},
+{"XML::Xercesc::DTDHandler_unparsedEntityDecl", _wrap_DTDHandler_unparsedEntityDecl},
+{"XML::Xercesc::delete_DocumentHandler", _wrap_delete_DocumentHandler},
+{"XML::Xercesc::DocumentHandler_characters", _wrap_DocumentHandler_characters},
+{"XML::Xercesc::DocumentHandler_processingInstruction", _wrap_DocumentHandler_processingInstruction},
+{"XML::Xercesc::DocumentHandler_setDocumentLocator", _wrap_DocumentHandler_setDocumentLocator},
+{"XML::Xercesc::delete_AttributeList", _wrap_delete_AttributeList},
+{"XML::Xercesc::AttributeList_getLength", _wrap_AttributeList_getLength},
+{"XML::Xercesc::AttributeList_getName", _wrap_AttributeList_getName},
+{"XML::Xercesc::AttributeList_getType", _wrap_AttributeList_getType},
+{"XML::Xercesc::AttributeList_getValue", _wrap_AttributeList_getValue},
+{"XML::Xercesc::HandlerBase_characters", _wrap_HandlerBase_characters},
+{"XML::Xercesc::HandlerBase_processingInstruction", _wrap_HandlerBase_processingInstruction},
+{"XML::Xercesc::HandlerBase_setDocumentLocator", _wrap_HandlerBase_setDocumentLocator},
+{"XML::Xercesc::HandlerBase_error", _wrap_HandlerBase_error},
+{"XML::Xercesc::HandlerBase_fatalError", _wrap_HandlerBase_fatalError},
+{"XML::Xercesc::HandlerBase_warning", _wrap_HandlerBase_warning},
+{"XML::Xercesc::HandlerBase_resetErrors", _wrap_HandlerBase_resetErrors},
+{"XML::Xercesc::HandlerBase_unparsedEntityDecl", _wrap_HandlerBase_unparsedEntityDecl},
+{"XML::Xercesc::new_HandlerBase", _wrap_new_HandlerBase},
+{"XML::Xercesc::delete_HandlerBase", _wrap_delete_HandlerBase},
+{"XML::Xercesc::delete_Locator", _wrap_delete_Locator},
+{"XML::Xercesc::Locator_getPublicId", _wrap_Locator_getPublicId},
+{"XML::Xercesc::Locator_getSystemId", _wrap_Locator_getSystemId},
+{"XML::Xercesc::Locator_getLineNumber", _wrap_Locator_getLineNumber},
+{"XML::Xercesc::Locator_getColumnNumber", _wrap_Locator_getColumnNumber},
+{"XML::Xercesc::delete_Attributes", _wrap_delete_Attributes},
+{"XML::Xercesc::Attributes_getLength", _wrap_Attributes_getLength},
+{"XML::Xercesc::Attributes_getURI", _wrap_Attributes_getURI},
+{"XML::Xercesc::Attributes_getLocalName", _wrap_Attributes_getLocalName},
+{"XML::Xercesc::Attributes_getQName", _wrap_Attributes_getQName},
+{"XML::Xercesc::Attributes_getIndex", _wrap_Attributes_getIndex},
+{"XML::Xercesc::Attributes_getType", _wrap_Attributes_getType},
+{"XML::Xercesc::Attributes_getValue", _wrap_Attributes_getValue},
+{"XML::Xercesc::delete_ContentHandler", _wrap_delete_ContentHandler},
+{"XML::Xercesc::ContentHandler_characters", _wrap_ContentHandler_characters},
+{"XML::Xercesc::ContentHandler_processingInstruction", _wrap_ContentHandler_processingInstruction},
+{"XML::Xercesc::ContentHandler_setDocumentLocator", _wrap_ContentHandler_setDocumentLocator},
+{"XML::Xercesc::ContentHandler_startPrefixMapping", _wrap_ContentHandler_startPrefixMapping},
+{"XML::Xercesc::ContentHandler_endPrefixMapping", _wrap_ContentHandler_endPrefixMapping},
+{"XML::Xercesc::ContentHandler_skippedEntity", _wrap_ContentHandler_skippedEntity},
+{"XML::Xercesc::delete_LexicalHandler", _wrap_delete_LexicalHandler},
+{"XML::Xercesc::LexicalHandler_comment", _wrap_LexicalHandler_comment},
+{"XML::Xercesc::LexicalHandler_endCDATA", _wrap_LexicalHandler_endCDATA},
+{"XML::Xercesc::LexicalHandler_endDTD", _wrap_LexicalHandler_endDTD},
+{"XML::Xercesc::LexicalHandler_endEntity", _wrap_LexicalHandler_endEntity},
+{"XML::Xercesc::LexicalHandler_startCDATA", _wrap_LexicalHandler_startCDATA},
+{"XML::Xercesc::LexicalHandler_startDTD", _wrap_LexicalHandler_startDTD},
+{"XML::Xercesc::LexicalHandler_startEntity", _wrap_LexicalHandler_startEntity},
+{"XML::Xercesc::delete_DeclHandler", _wrap_delete_DeclHandler},
+{"XML::Xercesc::DeclHandler_attributeDecl", _wrap_DeclHandler_attributeDecl},
+{"XML::Xercesc::DeclHandler_internalEntityDecl", _wrap_DeclHandler_internalEntityDecl},
+{"XML::Xercesc::DeclHandler_externalEntityDecl", _wrap_DeclHandler_externalEntityDecl},
+{"XML::Xercesc::delete_Parser", _wrap_delete_Parser},
+{"XML::Xercesc::Parser_setEntityResolver", _wrap_Parser_setEntityResolver},
+{"XML::Xercesc::Parser_setDTDHandler", _wrap_Parser_setDTDHandler},
+{"XML::Xercesc::Parser_setDocumentHandler", _wrap_Parser_setDocumentHandler},
+{"XML::Xercesc::Parser_setErrorHandler", _wrap_Parser_setErrorHandler},
+{"XML::Xercesc::Parser_parse", _wrap_Parser_parse},
+{"XML::Xercesc::new_SAXParser", _wrap_new_SAXParser},
+{"XML::Xercesc::delete_SAXParser", _wrap_delete_SAXParser},
+{"XML::Xercesc::SAXParser_getDocumentHandler", _wrap_SAXParser_getDocumentHandler},
+{"XML::Xercesc::SAXParser_getEntityResolver", _wrap_SAXParser_getEntityResolver},
+{"XML::Xercesc::SAXParser_getXMLEntityResolver", _wrap_SAXParser_getXMLEntityResolver},
+{"XML::Xercesc::SAXParser_getErrorHandler", _wrap_SAXParser_getErrorHandler},
+{"XML::Xercesc::SAXParser_getPSVIHandler", _wrap_SAXParser_getPSVIHandler},
+{"XML::Xercesc::SAXParser_getValidator", _wrap_SAXParser_getValidator},
+{"XML::Xercesc::SAXParser_getValidationScheme", _wrap_SAXParser_getValidationScheme},
+{"XML::Xercesc::SAXParser_getDoSchema", _wrap_SAXParser_getDoSchema},
+{"XML::Xercesc::SAXParser_getValidationSchemaFullChecking", _wrap_SAXParser_getValidationSchemaFullChecking},
+{"XML::Xercesc::SAXParser_getIdentityConstraintChecking", _wrap_SAXParser_getIdentityConstraintChecking},
+{"XML::Xercesc::SAXParser_getErrorCount", _wrap_SAXParser_getErrorCount},
+{"XML::Xercesc::SAXParser_getDoNamespaces", _wrap_SAXParser_getDoNamespaces},
+{"XML::Xercesc::SAXParser_getExitOnFirstFatalError", _wrap_SAXParser_getExitOnFirstFatalError},
+{"XML::Xercesc::SAXParser_getValidationConstraintFatal", _wrap_SAXParser_getValidationConstraintFatal},
+{"XML::Xercesc::SAXParser_getExternalSchemaLocation", _wrap_SAXParser_getExternalSchemaLocation},
+{"XML::Xercesc::SAXParser_getExternalNoNamespaceSchemaLocation", _wrap_SAXParser_getExternalNoNamespaceSchemaLocation},
+{"XML::Xercesc::SAXParser_getSecurityManager", _wrap_SAXParser_getSecurityManager},
+{"XML::Xercesc::SAXParser_getLoadExternalDTD", _wrap_SAXParser_getLoadExternalDTD},
+{"XML::Xercesc::SAXParser_isCachingGrammarFromParse", _wrap_SAXParser_isCachingGrammarFromParse},
+{"XML::Xercesc::SAXParser_isUsingCachedGrammarInParse", _wrap_SAXParser_isUsingCachedGrammarInParse},
+{"XML::Xercesc::SAXParser_getCalculateSrcOfs", _wrap_SAXParser_getCalculateSrcOfs},
+{"XML::Xercesc::SAXParser_getStandardUriConformant", _wrap_SAXParser_getStandardUriConformant},
+{"XML::Xercesc::SAXParser_getGrammar", _wrap_SAXParser_getGrammar},
+{"XML::Xercesc::SAXParser_getRootGrammar", _wrap_SAXParser_getRootGrammar},
+{"XML::Xercesc::SAXParser_getURIText", _wrap_SAXParser_getURIText},
+{"XML::Xercesc::SAXParser_getSrcOffset", _wrap_SAXParser_getSrcOffset},
+{"XML::Xercesc::SAXParser_getGenerateSyntheticAnnotations", _wrap_SAXParser_getGenerateSyntheticAnnotations},
+{"XML::Xercesc::SAXParser_getValidateAnnotations", _wrap_SAXParser_getValidateAnnotations},
+{"XML::Xercesc::SAXParser_getIgnoreCachedDTD", _wrap_SAXParser_getIgnoreCachedDTD},
+{"XML::Xercesc::SAXParser_getIgnoreAnnotations", _wrap_SAXParser_getIgnoreAnnotations},
+{"XML::Xercesc::SAXParser_getDisableDefaultEntityResolution", _wrap_SAXParser_getDisableDefaultEntityResolution},
+{"XML::Xercesc::SAXParser_getSkipDTDValidation", _wrap_SAXParser_getSkipDTDValidation},
+{"XML::Xercesc::SAXParser_setGenerateSyntheticAnnotations", _wrap_SAXParser_setGenerateSyntheticAnnotations},
+{"XML::Xercesc::SAXParser_setValidateAnnotations", _wrap_SAXParser_setValidateAnnotations},
+{"XML::Xercesc::SAXParser_setDoNamespaces", _wrap_SAXParser_setDoNamespaces},
+{"XML::Xercesc::SAXParser_setValidationScheme", _wrap_SAXParser_setValidationScheme},
+{"XML::Xercesc::SAXParser_setDoSchema", _wrap_SAXParser_setDoSchema},
+{"XML::Xercesc::SAXParser_setValidationSchemaFullChecking", _wrap_SAXParser_setValidationSchemaFullChecking},
+{"XML::Xercesc::SAXParser_setIdentityConstraintChecking", _wrap_SAXParser_setIdentityConstraintChecking},
+{"XML::Xercesc::SAXParser_setExitOnFirstFatalError", _wrap_SAXParser_setExitOnFirstFatalError},
+{"XML::Xercesc::SAXParser_setValidationConstraintFatal", _wrap_SAXParser_setValidationConstraintFatal},
+{"XML::Xercesc::SAXParser_setExternalSchemaLocation", _wrap_SAXParser_setExternalSchemaLocation},
+{"XML::Xercesc::SAXParser_setExternalNoNamespaceSchemaLocation", _wrap_SAXParser_setExternalNoNamespaceSchemaLocation},
+{"XML::Xercesc::SAXParser_setSecurityManager", _wrap_SAXParser_setSecurityManager},
+{"XML::Xercesc::SAXParser_setLoadExternalDTD", _wrap_SAXParser_setLoadExternalDTD},
+{"XML::Xercesc::SAXParser_cacheGrammarFromParse", _wrap_SAXParser_cacheGrammarFromParse},
+{"XML::Xercesc::SAXParser_useCachedGrammarInParse", _wrap_SAXParser_useCachedGrammarInParse},
+{"XML::Xercesc::SAXParser_setCalculateSrcOfs", _wrap_SAXParser_setCalculateSrcOfs},
+{"XML::Xercesc::SAXParser_setStandardUriConformant", _wrap_SAXParser_setStandardUriConformant},
+{"XML::Xercesc::SAXParser_useScanner", _wrap_SAXParser_useScanner},
+{"XML::Xercesc::SAXParser_setInputBufferSize", _wrap_SAXParser_setInputBufferSize},
+{"XML::Xercesc::SAXParser_setIgnoreCachedDTD", _wrap_SAXParser_setIgnoreCachedDTD},
+{"XML::Xercesc::SAXParser_setIgnoreAnnotations", _wrap_SAXParser_setIgnoreAnnotations},
+{"XML::Xercesc::SAXParser_setDisableDefaultEntityResolution", _wrap_SAXParser_setDisableDefaultEntityResolution},
+{"XML::Xercesc::SAXParser_setSkipDTDValidation", _wrap_SAXParser_setSkipDTDValidation},
+{"XML::Xercesc::SAXParser_installAdvDocHandler", _wrap_SAXParser_installAdvDocHandler},
+{"XML::Xercesc::SAXParser_removeAdvDocHandler", _wrap_SAXParser_removeAdvDocHandler},
+{"XML::Xercesc::SAXParser_parseFirst", _wrap_SAXParser_parseFirst},
+{"XML::Xercesc::SAXParser_parseNext", _wrap_SAXParser_parseNext},
+{"XML::Xercesc::SAXParser_parseReset", _wrap_SAXParser_parseReset},
+{"XML::Xercesc::SAXParser_loadGrammar", _wrap_SAXParser_loadGrammar},
+{"XML::Xercesc::SAXParser_resetCachedGrammarPool", _wrap_SAXParser_resetCachedGrammarPool},
+{"XML::Xercesc::SAXParser_parse", _wrap_SAXParser_parse},
+{"XML::Xercesc::SAXParser_setDocumentHandler", _wrap_SAXParser_setDocumentHandler},
+{"XML::Xercesc::SAXParser_setDTDHandler", _wrap_SAXParser_setDTDHandler},
+{"XML::Xercesc::SAXParser_setErrorHandler", _wrap_SAXParser_setErrorHandler},
+{"XML::Xercesc::SAXParser_setPSVIHandler", _wrap_SAXParser_setPSVIHandler},
+{"XML::Xercesc::SAXParser_setEntityResolver", _wrap_SAXParser_setEntityResolver},
+{"XML::Xercesc::SAXParser_setXMLEntityResolver", _wrap_SAXParser_setXMLEntityResolver},
+{"XML::Xercesc::SAXParser_error", _wrap_SAXParser_error},
+{"XML::Xercesc::SAXParser_resetErrors", _wrap_SAXParser_resetErrors},
+{"XML::Xercesc::delete_SAX2XMLReader", _wrap_delete_SAX2XMLReader},
+{"XML::Xercesc::SAX2XMLReader_getContentHandler", _wrap_SAX2XMLReader_getContentHandler},
+{"XML::Xercesc::SAX2XMLReader_getDTDHandler", _wrap_SAX2XMLReader_getDTDHandler},
+{"XML::Xercesc::SAX2XMLReader_getFeature", _wrap_SAX2XMLReader_getFeature},
+{"XML::Xercesc::SAX2XMLReader_getProperty", _wrap_SAX2XMLReader_getProperty},
+{"XML::Xercesc::SAX2XMLReader_setContentHandler", _wrap_SAX2XMLReader_setContentHandler},
+{"XML::Xercesc::SAX2XMLReader_setDTDHandler", _wrap_SAX2XMLReader_setDTDHandler},
+{"XML::Xercesc::SAX2XMLReader_setEntityResolver", _wrap_SAX2XMLReader_setEntityResolver},
+{"XML::Xercesc::SAX2XMLReader_setErrorHandler", _wrap_SAX2XMLReader_setErrorHandler},
+{"XML::Xercesc::SAX2XMLReader_setFeature", _wrap_SAX2XMLReader_setFeature},
+{"XML::Xercesc::SAX2XMLReader_setProperty", _wrap_SAX2XMLReader_setProperty},
+{"XML::Xercesc::SAX2XMLReader_parse", _wrap_SAX2XMLReader_parse},
+{"XML::Xercesc::SAX2XMLReader_getDeclarationHandler", _wrap_SAX2XMLReader_getDeclarationHandler},
+{"XML::Xercesc::SAX2XMLReader_getLexicalHandler", _wrap_SAX2XMLReader_getLexicalHandler},
+{"XML::Xercesc::SAX2XMLReader_setDeclarationHandler", _wrap_SAX2XMLReader_setDeclarationHandler},
+{"XML::Xercesc::SAX2XMLReader_setLexicalHandler", _wrap_SAX2XMLReader_setLexicalHandler},
+{"XML::Xercesc::SAX2XMLReader_getValidator", _wrap_SAX2XMLReader_getValidator},
+{"XML::Xercesc::SAX2XMLReader_getErrorCount", _wrap_SAX2XMLReader_getErrorCount},
+{"XML::Xercesc::SAX2XMLReader_getExitOnFirstFatalError", _wrap_SAX2XMLReader_getExitOnFirstFatalError},
+{"XML::Xercesc::SAX2XMLReader_getValidationConstraintFatal", _wrap_SAX2XMLReader_getValidationConstraintFatal},
+{"XML::Xercesc::SAX2XMLReader_getGrammar", _wrap_SAX2XMLReader_getGrammar},
+{"XML::Xercesc::SAX2XMLReader_getRootGrammar", _wrap_SAX2XMLReader_getRootGrammar},
+{"XML::Xercesc::SAX2XMLReader_getURIText", _wrap_SAX2XMLReader_getURIText},
+{"XML::Xercesc::SAX2XMLReader_getSrcOffset", _wrap_SAX2XMLReader_getSrcOffset},
+{"XML::Xercesc::SAX2XMLReader_setValidator", _wrap_SAX2XMLReader_setValidator},
+{"XML::Xercesc::SAX2XMLReader_setExitOnFirstFatalError", _wrap_SAX2XMLReader_setExitOnFirstFatalError},
+{"XML::Xercesc::SAX2XMLReader_setValidationConstraintFatal", _wrap_SAX2XMLReader_setValidationConstraintFatal},
+{"XML::Xercesc::SAX2XMLReader_parseFirst", _wrap_SAX2XMLReader_parseFirst},
+{"XML::Xercesc::SAX2XMLReader_parseNext", _wrap_SAX2XMLReader_parseNext},
+{"XML::Xercesc::SAX2XMLReader_parseReset", _wrap_SAX2XMLReader_parseReset},
+{"XML::Xercesc::SAX2XMLReader_loadGrammar", _wrap_SAX2XMLReader_loadGrammar},
+{"XML::Xercesc::SAX2XMLReader_resetCachedGrammarPool", _wrap_SAX2XMLReader_resetCachedGrammarPool},
+{"XML::Xercesc::SAX2XMLReader_setInputBufferSize", _wrap_SAX2XMLReader_setInputBufferSize},
+{"XML::Xercesc::SAX2XMLReader_installAdvDocHandler", _wrap_SAX2XMLReader_installAdvDocHandler},
+{"XML::Xercesc::SAX2XMLReader_removeAdvDocHandler", _wrap_SAX2XMLReader_removeAdvDocHandler},
+{"XML::Xercesc::XMLReaderFactory_createXMLReader", _wrap_XMLReaderFactory_createXMLReader},
+{"XML::Xercesc::new_PerlSAXCallbackHandler", _wrap_new_PerlSAXCallbackHandler},
+{"XML::Xercesc::delete_PerlSAXCallbackHandler", _wrap_delete_PerlSAXCallbackHandler},
+{"XML::Xercesc::PerlSAXCallbackHandler_type", _wrap_PerlSAXCallbackHandler_type},
+{"XML::Xercesc::PerlSAXCallbackHandler_characters", _wrap_PerlSAXCallbackHandler_characters},
+{"XML::Xercesc::PerlSAXCallbackHandler_processingInstruction", _wrap_PerlSAXCallbackHandler_processingInstruction},
+{"XML::Xercesc::PerlSAXCallbackHandler_setDocumentLocator", _wrap_PerlSAXCallbackHandler_setDocumentLocator},
+{"XML::Xercesc::PerlSAXCallbackHandler_startPrefixMapping", _wrap_PerlSAXCallbackHandler_startPrefixMapping},
+{"XML::Xercesc::PerlSAXCallbackHandler_endPrefixMapping", _wrap_PerlSAXCallbackHandler_endPrefixMapping},
+{"XML::Xercesc::PerlSAXCallbackHandler_skippedEntity", _wrap_PerlSAXCallbackHandler_skippedEntity},
+{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__Grammar->dcast = (swig_dycast_func) Grammar_dynamic_cast;
+
+
+ SWIGTYPE_p_XERCES_CPP_NAMESPACE__XMLGrammarDescription->dcast = (swig_dycast_func) XMLGrammarDescription_dynamic_cast;
+
+
+ // 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_XERCES_CPP_NAMESPACE__DTDHandler, (void*) "XML::Xerces::DTDHandler");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DocumentHandler, (void*) "XML::Xerces::DocumentHandler");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__AttributeList, (void*) "XML::Xerces::AttributeList");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__HandlerBase, (void*) "XML::Xerces::HandlerBase");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Locator, (void*) "XML::Xerces::Locator");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__Attributes, (void*) "XML::Xerces::Attributes");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__ContentHandler, (void*) "XML::Xerces::ContentHandler");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__LexicalHandler, (void*) "XML::Xerces::LexicalHandler");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DeclHandler, (void*) "XML::Xerces::DeclHandler");
+ 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);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::SAXParser::Val_Never)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "SAXParser_Val_Always", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::SAXParser::Val_Always)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "SAXParser_Val_Auto", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::SAXParser::Val_Auto)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__SAXParser, (void*) "XML::Xerces::SAXParser");
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "SAX2XMLReader_Val_Never", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::SAX2XMLReader::Val_Never)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "SAX2XMLReader_Val_Always", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::SAX2XMLReader::Val_Always)));
+ SvREADONLY_on(sv);
+ } while(0) /*@SWIG@*/;
+ /*@SWIG:%set_constant@*/ do {
+ SV *sv = get_sv((char*) SWIG_prefix "SAX2XMLReader_Val_Auto", TRUE | 0x2);
+ sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1(static_cast< int >(XERCES_CPP_NAMESPACE::SAX2XMLReader::Val_Auto)));
+ SvREADONLY_on(sv);
+ } 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");
+ SWIG_TypeClientData(SWIGTYPE_p_XERCES_CPP_NAMESPACE__PerlSAXCallbackHandler, (void*) "XML::Xerces::PerlSAXCallbackHandler");
+ ST(0) = &PL_sv_yes;
+ XSRETURN(1);
+}
+