You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xerces.apache.org by ja...@apache.org on 2002/02/21 04:10:27 UTC
cvs commit: xml-xerces/perl Xerces.C Xerces.i Xerces.pm
jasons 02/02/20 19:10:27
Modified: perl Xerces.C Xerces.i Xerces.pm
Log:
* Xerces.pm (Repository):
* Xerces.i (Repository):
* Xerces.C (Repository):
included "validators/common/Grammar.hpp"
now wraps 1.6.0
Revision Changes Path
1.5 +2970 -433 xml-xerces/perl/Xerces.C
Index: Xerces.C
===================================================================
RCS file: /home/cvs/xml-xerces/perl/Xerces.C,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- Xerces.C 3 Nov 2001 05:11:04 -0000 1.4
+++ Xerces.C 21 Feb 2002 03:10:25 -0000 1.5
@@ -353,8 +353,8 @@
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_IDOM_NodeIterator swig_types[0]
-#define SWIGTYPE_p_DOM_Document swig_types[1]
-#define SWIGTYPE_p_IDOM_Document swig_types[2]
+#define SWIGTYPE_p_IDOM_Document swig_types[1]
+#define SWIGTYPE_p_DOM_Document swig_types[2]
#define SWIGTYPE_p_DOM_NodeIterator swig_types[3]
#define SWIGTYPE_p_IDOM_DOMImplementation swig_types[4]
#define SWIGTYPE_p_DOM_DOMImplementation swig_types[5]
@@ -364,99 +364,101 @@
#define SWIGTYPE_p_DOM_XMLDecl swig_types[9]
#define SWIGTYPE_p_XMLAttr swig_types[10]
#define SWIGTYPE_p_AttributeList swig_types[11]
-#define SWIGTYPE_p_IDOM_NodeFilter swig_types[12]
-#define SWIGTYPE_p_QName swig_types[13]
-#define SWIGTYPE_p_p_QName swig_types[14]
-#define SWIGTYPE_p_DOM_NodeFilter swig_types[15]
-#define SWIGTYPE_p_IDOM_DocumentType swig_types[16]
-#define SWIGTYPE_p_DOM_DocumentType swig_types[17]
-#define SWIGTYPE_p_XMLElementDecl swig_types[18]
-#define SWIGTYPE_p_p_void swig_types[19]
-#define SWIGTYPE_p_void swig_types[20]
-#define SWIGTYPE_p_IDOM_EntityReference swig_types[21]
-#define SWIGTYPE_p_DOM_EntityReference swig_types[22]
-#define SWIGTYPE_p_int swig_types[23]
-#define SWIGTYPE_p_IDOM_Notation swig_types[24]
-#define SWIGTYPE_p_DOM_Notation swig_types[25]
-#define SWIGTYPE_p_IDOM_RangeException swig_types[26]
-#define SWIGTYPE_p_IDOM_DOMException swig_types[27]
-#define SWIGTYPE_p_XMLException swig_types[28]
-#define SWIGTYPE_p_SAXException swig_types[29]
-#define SWIGTYPE_p_SAXNotSupportedException swig_types[30]
-#define SWIGTYPE_p_SAXNotRecognizedException swig_types[31]
-#define SWIGTYPE_p_SAXParseException swig_types[32]
-#define SWIGTYPE_p_XMLErrorReporter swig_types[33]
-#define SWIGTYPE_p_DOM_DOMException swig_types[34]
-#define SWIGTYPE_p_DOM_RangeException swig_types[35]
-#define SWIGTYPE_p_XMLDeleter swig_types[36]
-#define SWIGTYPE_p_Attributes swig_types[37]
-#define SWIGTYPE_p_FileHandle swig_types[38]
-#define SWIGTYPE_p_DOMString swig_types[39]
-#define SWIGTYPE_p_XMLScanner swig_types[40]
-#define SWIGTYPE_p_DOMParser swig_types[41]
-#define SWIGTYPE_p_IDOMParser swig_types[42]
-#define SWIGTYPE_p_XMLByte swig_types[43]
-#define SWIGTYPE_p_XMLURL swig_types[44]
-#define SWIGTYPE_p_XMLAttDef swig_types[45]
-#define SWIGTYPE_p_EntityResolver swig_types[46]
-#define SWIGTYPE_p_PerlEntityResolverHandler swig_types[47]
-#define SWIGTYPE_p_PerlContentCallbackHandler swig_types[48]
-#define SWIGTYPE_p_PerlDocumentCallbackHandler swig_types[49]
-#define SWIGTYPE_p_PerlErrorCallbackHandler swig_types[50]
-#define SWIGTYPE_p_DefaultHandler swig_types[51]
-#define SWIGTYPE_p_LexicalHandler swig_types[52]
-#define SWIGTYPE_p_ContentHandler swig_types[53]
-#define SWIGTYPE_p_ErrorHandler swig_types[54]
-#define SWIGTYPE_p_DTDHandler swig_types[55]
-#define SWIGTYPE_p_DocumentHandler swig_types[56]
-#define SWIGTYPE_p_XMLDocumentHandler swig_types[57]
-#define SWIGTYPE_p_IDOM_TreeWalker swig_types[58]
-#define SWIGTYPE_p_DOM_TreeWalker swig_types[59]
-#define SWIGTYPE_p_IDOM_Range swig_types[60]
-#define SWIGTYPE_p_DOM_Range swig_types[61]
-#define SWIGTYPE_p_DOM_Node swig_types[62]
-#define SWIGTYPE_p_IDOM_Node swig_types[63]
-#define SWIGTYPE_p_XMLValid__Codes swig_types[64]
-#define SWIGTYPE_p_XMLMsgLoader swig_types[65]
-#define SWIGTYPE_p_XMLBufferMgr swig_types[66]
-#define SWIGTYPE_p_Locator swig_types[67]
-#define SWIGTYPE_p_IDOM_DocumentFragment swig_types[68]
-#define SWIGTYPE_p_IDOM_CharacterData swig_types[69]
-#define SWIGTYPE_p_DOM_CharacterData swig_types[70]
-#define SWIGTYPE_p_DOM_DocumentFragment swig_types[71]
-#define SWIGTYPE_p_BinInputStream swig_types[72]
-#define SWIGTYPE_p_InputSource swig_types[73]
-#define SWIGTYPE_p_DOM_NamedNodeMap swig_types[74]
-#define SWIGTYPE_p_IDOM_NamedNodeMap swig_types[75]
-#define SWIGTYPE_p_MemBufInputSource swig_types[76]
-#define SWIGTYPE_p_StdInInputSource swig_types[77]
-#define SWIGTYPE_p_LocalFileInputSource swig_types[78]
-#define SWIGTYPE_p_URLInputSource swig_types[79]
-#define SWIGTYPE_p_ReaderMgr swig_types[80]
-#define SWIGTYPE_p_DOM_NodeList swig_types[81]
-#define SWIGTYPE_p_IDOM_NodeList swig_types[82]
-#define SWIGTYPE_p_Grammar swig_types[83]
-#define SWIGTYPE_p_SAX2XMLReader swig_types[84]
-#define SWIGTYPE_p_SV swig_types[85]
-#define SWIGTYPE_p_IDOM_Comment swig_types[86]
-#define SWIGTYPE_p_DOM_Comment swig_types[87]
-#define SWIGTYPE_p_SAXParser swig_types[88]
-#define SWIGTYPE_p_HandlerBase swig_types[89]
-#define SWIGTYPE_p_XMLUri swig_types[90]
-#define SWIGTYPE_p_IDOM_ProcessingInstruction swig_types[91]
-#define SWIGTYPE_p_DOM_ProcessingInstruction swig_types[92]
-#define SWIGTYPE_p_IDOM_Attr swig_types[93]
-#define SWIGTYPE_p_IDOM_CDATASection swig_types[94]
-#define SWIGTYPE_p_DOM_Attr swig_types[95]
-#define SWIGTYPE_p_DOM_CDATASection swig_types[96]
-#define SWIGTYPE_p_XMLErrorReporter__ErrTypes swig_types[97]
-#define SWIGTYPE_p_XMLPScanToken swig_types[98]
-#define SWIGTYPE_p_IDOM_Element swig_types[99]
-#define SWIGTYPE_p_IDOM_Entity swig_types[100]
-#define SWIGTYPE_p_XMLValidator swig_types[101]
-#define SWIGTYPE_p_DOM_Element swig_types[102]
-#define SWIGTYPE_p_DOM_Entity swig_types[103]
-static swig_type_info *swig_types[105];
+#define SWIGTYPE_p_bool swig_types[12]
+#define SWIGTYPE_p_IDOM_NodeFilter swig_types[13]
+#define SWIGTYPE_p_QName swig_types[14]
+#define SWIGTYPE_p_p_QName swig_types[15]
+#define SWIGTYPE_p_DOM_NodeFilter swig_types[16]
+#define SWIGTYPE_p_XMLNotationDecl swig_types[17]
+#define SWIGTYPE_p_IDOM_DocumentType swig_types[18]
+#define SWIGTYPE_p_DOM_DocumentType swig_types[19]
+#define SWIGTYPE_p_XMLElementDecl swig_types[20]
+#define SWIGTYPE_p_p_void swig_types[21]
+#define SWIGTYPE_p_void swig_types[22]
+#define SWIGTYPE_p_IDOM_EntityReference swig_types[23]
+#define SWIGTYPE_p_DOM_EntityReference swig_types[24]
+#define SWIGTYPE_p_int swig_types[25]
+#define SWIGTYPE_p_IDOM_Notation swig_types[26]
+#define SWIGTYPE_p_DOM_Notation swig_types[27]
+#define SWIGTYPE_p_IDOM_RangeException swig_types[28]
+#define SWIGTYPE_p_IDOM_DOMException swig_types[29]
+#define SWIGTYPE_p_XMLException swig_types[30]
+#define SWIGTYPE_p_SAXException swig_types[31]
+#define SWIGTYPE_p_SAXNotSupportedException swig_types[32]
+#define SWIGTYPE_p_SAXNotRecognizedException swig_types[33]
+#define SWIGTYPE_p_SAXParseException swig_types[34]
+#define SWIGTYPE_p_XMLErrorReporter swig_types[35]
+#define SWIGTYPE_p_DOM_DOMException swig_types[36]
+#define SWIGTYPE_p_DOM_RangeException swig_types[37]
+#define SWIGTYPE_p_XMLDeleter swig_types[38]
+#define SWIGTYPE_p_Attributes swig_types[39]
+#define SWIGTYPE_p_FileHandle swig_types[40]
+#define SWIGTYPE_p_DOMString swig_types[41]
+#define SWIGTYPE_p_XMLScanner swig_types[42]
+#define SWIGTYPE_p_DOMParser swig_types[43]
+#define SWIGTYPE_p_IDOMParser swig_types[44]
+#define SWIGTYPE_p_XMLByte swig_types[45]
+#define SWIGTYPE_p_XMLURL swig_types[46]
+#define SWIGTYPE_p_XMLAttDef swig_types[47]
+#define SWIGTYPE_p_EntityResolver swig_types[48]
+#define SWIGTYPE_p_PerlEntityResolverHandler swig_types[49]
+#define SWIGTYPE_p_PerlContentCallbackHandler swig_types[50]
+#define SWIGTYPE_p_PerlDocumentCallbackHandler swig_types[51]
+#define SWIGTYPE_p_PerlErrorCallbackHandler swig_types[52]
+#define SWIGTYPE_p_DefaultHandler swig_types[53]
+#define SWIGTYPE_p_LexicalHandler swig_types[54]
+#define SWIGTYPE_p_ContentHandler swig_types[55]
+#define SWIGTYPE_p_ErrorHandler swig_types[56]
+#define SWIGTYPE_p_DTDHandler swig_types[57]
+#define SWIGTYPE_p_DocumentHandler swig_types[58]
+#define SWIGTYPE_p_XMLDocumentHandler swig_types[59]
+#define SWIGTYPE_p_IDOM_TreeWalker swig_types[60]
+#define SWIGTYPE_p_DOM_TreeWalker swig_types[61]
+#define SWIGTYPE_p_IDOM_Range swig_types[62]
+#define SWIGTYPE_p_DOM_Range swig_types[63]
+#define SWIGTYPE_p_DOM_Node swig_types[64]
+#define SWIGTYPE_p_IDOM_Node swig_types[65]
+#define SWIGTYPE_p_XMLValid__Codes swig_types[66]
+#define SWIGTYPE_p_XMLMsgLoader swig_types[67]
+#define SWIGTYPE_p_XMLBufferMgr swig_types[68]
+#define SWIGTYPE_p_Locator swig_types[69]
+#define SWIGTYPE_p_IDOM_DocumentFragment swig_types[70]
+#define SWIGTYPE_p_IDOM_CharacterData swig_types[71]
+#define SWIGTYPE_p_DOM_CharacterData swig_types[72]
+#define SWIGTYPE_p_DOM_DocumentFragment swig_types[73]
+#define SWIGTYPE_p_BinInputStream swig_types[74]
+#define SWIGTYPE_p_InputSource swig_types[75]
+#define SWIGTYPE_p_DOM_NamedNodeMap swig_types[76]
+#define SWIGTYPE_p_IDOM_NamedNodeMap swig_types[77]
+#define SWIGTYPE_p_MemBufInputSource swig_types[78]
+#define SWIGTYPE_p_StdInInputSource swig_types[79]
+#define SWIGTYPE_p_LocalFileInputSource swig_types[80]
+#define SWIGTYPE_p_URLInputSource swig_types[81]
+#define SWIGTYPE_p_ReaderMgr swig_types[82]
+#define SWIGTYPE_p_DOM_NodeList swig_types[83]
+#define SWIGTYPE_p_IDOM_NodeList swig_types[84]
+#define SWIGTYPE_p_Grammar swig_types[85]
+#define SWIGTYPE_p_SAX2XMLReader swig_types[86]
+#define SWIGTYPE_p_SV swig_types[87]
+#define SWIGTYPE_p_IDOM_Comment swig_types[88]
+#define SWIGTYPE_p_DOM_Comment swig_types[89]
+#define SWIGTYPE_p_SAXParser swig_types[90]
+#define SWIGTYPE_p_HandlerBase swig_types[91]
+#define SWIGTYPE_p_XMLUri swig_types[92]
+#define SWIGTYPE_p_IDOM_ProcessingInstruction swig_types[93]
+#define SWIGTYPE_p_DOM_ProcessingInstruction swig_types[94]
+#define SWIGTYPE_p_IDOM_Attr swig_types[95]
+#define SWIGTYPE_p_IDOM_CDATASection swig_types[96]
+#define SWIGTYPE_p_DOM_Attr swig_types[97]
+#define SWIGTYPE_p_DOM_CDATASection swig_types[98]
+#define SWIGTYPE_p_XMLErrorReporter__ErrTypes swig_types[99]
+#define SWIGTYPE_p_XMLPScanToken swig_types[100]
+#define SWIGTYPE_p_IDOM_Element swig_types[101]
+#define SWIGTYPE_p_IDOM_Entity swig_types[102]
+#define SWIGTYPE_p_XMLValidator swig_types[103]
+#define SWIGTYPE_p_DOM_Element swig_types[104]
+#define SWIGTYPE_p_DOM_Entity swig_types[105]
+static swig_type_info *swig_types[107];
/* -------- TYPES TABLE (END) -------- */
@@ -509,6 +511,8 @@
#include "framework/StdInInputSource.hpp"
#include "framework/URLInputSource.hpp"
#include "framework/XMLValidator.hpp"
+#include "validators/common/Grammar.hpp"
+
#include "PerlErrorCallbackHandler.hpp"
#include "PerlEntityResolverHandler.i"
#include "PerlDocumentCallbackHandler.hpp"
@@ -5682,6 +5686,194 @@
XSRETURN(argvi);
}
+XS(_wrap_QName_setNPrefix) {
+ QName *arg1 ;
+ XMLCh *arg2 ;
+ unsigned int arg3 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3))
+ croak("Usage: QName_setNPrefix(self,arg1,arg2);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_QName) < 0) {
+ croak("Type error in argument 1 of QName_setNPrefix. Expected %s", SWIGTYPE_p_QName->name);
+ XSRETURN(1);
+ }
+ {
+ if (SvPOK(ST(1))||SvIOK(ST(1))||SvNOK(ST(1))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(1),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(1))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg2 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg2,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg2[chars_stored] = '\0';
+ }else {
+ arg2 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg2[i];i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of QName_setNPrefix, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ arg3 = (unsigned int )SvIV(ST(2));
+ {
+ try {
+ (arg1)->setNPrefix((XMLCh const *)arg2,arg3);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }{
+ delete[] arg2;
+ }
+ XSRETURN(argvi);
+}
+
+XS(_wrap_QName_setNLocalPart) {
+ QName *arg1 ;
+ XMLCh *arg2 ;
+ unsigned int arg3 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 3) || (items > 3))
+ croak("Usage: QName_setNLocalPart(self,arg1,arg2);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_QName) < 0) {
+ croak("Type error in argument 1 of QName_setNLocalPart. Expected %s", SWIGTYPE_p_QName->name);
+ XSRETURN(1);
+ }
+ {
+ if (SvPOK(ST(1))||SvIOK(ST(1))||SvNOK(ST(1))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(1),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(1))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg2 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg2,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg2[chars_stored] = '\0';
+ }else {
+ arg2 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg2[i];i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of QName_setNLocalPart, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ arg3 = (unsigned int )SvIV(ST(2));
+ {
+ try {
+ (arg1)->setNLocalPart((XMLCh const *)arg2,arg3);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }{
+ delete[] arg2;
+ }
+ XSRETURN(argvi);
+}
+
XS(_wrap_QName_setURI) {
QName *arg1 ;
unsigned int arg2 ;
@@ -6672,6 +6864,49 @@
XSRETURN(argvi);
}
+XS(_wrap_XMLException_getErrorType) {
+ XMLException *arg1 ;
+ int argvi = 0;
+ XMLErrorReporter::ErrTypes *result ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1))
+ croak("Usage: XMLException_getErrorType(self);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_XMLException) < 0) {
+ croak("Type error in argument 1 of XMLException_getErrorType. Expected %s", SWIGTYPE_p_XMLException->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ result = new XMLErrorReporter::ErrTypes (((XMLException const *)arg1)->getErrorType());
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_XMLErrorReporter__ErrTypes);
+ XSRETURN(argvi);
+}
+
XS(_wrap_XMLException_setPosition) {
XMLException *arg1 ;
char *arg2 ;
@@ -6766,20 +7001,15 @@
}XSRETURN(argvi);
}
-XS(_wrap_delete_XMLValidator) {
- XMLValidator *arg1 ;
+XS(_wrap_XMLException_reinitMsgMutex) {
int argvi = 0;
dXSARGS;
- if ((items < 1) || (items > 1))
- croak("Usage: delete_XMLValidator(self);");
- if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_XMLValidator) < 0) {
- croak("Type error in argument 1 of delete_XMLValidator. Expected %s", SWIGTYPE_p_XMLValidator->name);
- XSRETURN(1);
- }
+ if ((items < 0) || (items > 0))
+ croak("Usage: XMLException_reinitMsgMutex();");
{
try {
- delete arg1;
+ XMLException::reinitMsgMutex();
}
catch (const XMLException& e)
@@ -6806,33 +7036,55 @@
}XSRETURN(argvi);
}
-XS(_wrap_XMLValidator_checkContent) {
+XS(_wrap_XMLException_reinitMsgLoader) {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0))
+ croak("Usage: XMLException_reinitMsgLoader();");
+ {
+ try {
+ XMLException::reinitMsgLoader();
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
+}
+
+XS(_wrap_delete_XMLValidator) {
XMLValidator *arg1 ;
- XMLElementDecl *arg2 ;
- QName **arg3 ;
- unsigned int arg4 ;
int argvi = 0;
- int result ;
dXSARGS;
- if ((items < 4) || (items > 4))
- croak("Usage: XMLValidator_checkContent(self,elemDecl,children,childCount);");
+ if ((items < 1) || (items > 1))
+ croak("Usage: delete_XMLValidator(self);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_XMLValidator) < 0) {
- croak("Type error in argument 1 of XMLValidator_checkContent. Expected %s", SWIGTYPE_p_XMLValidator->name);
- XSRETURN(1);
- }
- if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_XMLElementDecl) < 0) {
- croak("Type error in argument 2 of XMLValidator_checkContent. Expected %s", SWIGTYPE_p_XMLElementDecl->name);
- XSRETURN(1);
- }
- if (SWIG_ConvertPtr(ST(2),(void **) &arg3,SWIGTYPE_p_p_QName) < 0) {
- croak("Type error in argument 3 of XMLValidator_checkContent. Expected %s", SWIGTYPE_p_p_QName->name);
+ croak("Type error in argument 1 of delete_XMLValidator. Expected %s", SWIGTYPE_p_XMLValidator->name);
XSRETURN(1);
}
- arg4 = (unsigned int )SvIV(ST(3));
{
try {
- result = (int )(arg1)->checkContent(arg2,arg3,arg4);
+ delete arg1;
}
catch (const XMLException& e)
@@ -6856,28 +7108,36 @@
XMLPlatformUtils::Terminate();
croak("%s", "Handling Unknown exception");
}
- }ST(argvi) = sv_newmortal();
- sv_setiv(ST(argvi++),(IV) result);
- XSRETURN(argvi);
+ }XSRETURN(argvi);
}
-XS(_wrap_XMLValidator_checkRootElement) {
+XS(_wrap_XMLValidator_checkContent) {
XMLValidator *arg1 ;
- unsigned int arg2 ;
+ XMLElementDecl *arg2 ;
+ QName **arg3 ;
+ unsigned int arg4 ;
int argvi = 0;
- bool result ;
+ int result ;
dXSARGS;
- if ((items < 2) || (items > 2))
- croak("Usage: XMLValidator_checkRootElement(self,elemId);");
+ if ((items < 4) || (items > 4))
+ croak("Usage: XMLValidator_checkContent(self,elemDecl,children,childCount);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_XMLValidator) < 0) {
- croak("Type error in argument 1 of XMLValidator_checkRootElement. Expected %s", SWIGTYPE_p_XMLValidator->name);
+ croak("Type error in argument 1 of XMLValidator_checkContent. Expected %s", SWIGTYPE_p_XMLValidator->name);
XSRETURN(1);
}
- arg2 = (unsigned int )SvIV(ST(1));
+ if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_XMLElementDecl) < 0) {
+ croak("Type error in argument 2 of XMLValidator_checkContent. Expected %s", SWIGTYPE_p_XMLElementDecl->name);
+ XSRETURN(1);
+ }
+ if (SWIG_ConvertPtr(ST(2),(void **) &arg3,SWIGTYPE_p_p_QName) < 0) {
+ croak("Type error in argument 3 of XMLValidator_checkContent. Expected %s", SWIGTYPE_p_p_QName->name);
+ XSRETURN(1);
+ }
+ arg4 = (unsigned int )SvIV(ST(3));
{
try {
- result = (bool )(arg1)->checkRootElement(arg2);
+ result = (int )(arg1)->checkContent(arg2,arg3,arg4);
}
catch (const XMLException& e)
@@ -7582,15 +7842,95 @@
}XSRETURN(argvi);
}
-XS(_wrap_XMLValidator_reinitXMLValidator) {
+XS(_wrap_XMLValidator_checkRootElement) {
+ XMLValidator *arg1 ;
+ unsigned int arg2 ;
+ int argvi = 0;
+ bool result ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2))
+ croak("Usage: XMLValidator_checkRootElement(self,elemId);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_XMLValidator) < 0) {
+ croak("Type error in argument 1 of XMLValidator_checkRootElement. Expected %s", SWIGTYPE_p_XMLValidator->name);
+ XSRETURN(1);
+ }
+ arg2 = (unsigned int )SvIV(ST(1));
+ {
+ try {
+ result = (bool )(arg1)->checkRootElement(arg2);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++),(IV) result);
+ XSRETURN(argvi);
+}
+
+XS(_wrap_XMLValidator_reinitMsgMutex) {
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 0) || (items > 0))
+ croak("Usage: XMLValidator_reinitMsgMutex();");
+ {
+ try {
+ XMLValidator::reinitMsgMutex();
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
+}
+
+XS(_wrap_XMLValidator_reinitMsgLoader) {
int argvi = 0;
dXSARGS;
if ((items < 0) || (items > 0))
- croak("Usage: XMLValidator_reinitXMLValidator();");
+ croak("Usage: XMLValidator_reinitMsgLoader();");
{
try {
- XMLValidator::reinitXMLValidator();
+ XMLValidator::reinitMsgLoader();
}
catch (const XMLException& e)
@@ -54106,6 +54446,49 @@
XSRETURN(argvi);
}
+XS(_wrap_InputSource_getIssueFatalErrorIfNotFound) {
+ InputSource *arg1 ;
+ int argvi = 0;
+ bool result ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1))
+ croak("Usage: InputSource_getIssueFatalErrorIfNotFound(self);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_InputSource) < 0) {
+ croak("Type error in argument 1 of InputSource_getIssueFatalErrorIfNotFound. Expected %s", SWIGTYPE_p_InputSource->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ result = (bool )((InputSource const *)arg1)->getIssueFatalErrorIfNotFound();
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++),(IV) result);
+ XSRETURN(argvi);
+}
+
XS(_wrap_InputSource_setEncoding) {
InputSource *arg1 ;
XMLCh *arg2 ;
@@ -54382,6 +54765,48 @@
XSRETURN(argvi);
}
+XS(_wrap_InputSource_setIssueFatalErrorIfNotFound) {
+ InputSource *arg1 ;
+ bool arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2))
+ croak("Usage: InputSource_setIssueFatalErrorIfNotFound(self,flag);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_InputSource) < 0) {
+ croak("Type error in argument 1 of InputSource_setIssueFatalErrorIfNotFound. Expected %s", SWIGTYPE_p_InputSource->name);
+ XSRETURN(1);
+ }
+ arg2 = (bool )SvIV(ST(1));
+ {
+ try {
+ (arg1)->setIssueFatalErrorIfNotFound(arg2);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
+}
+
XS(_wrap_new_MemBufInputSource) {
XMLByte *arg1 ;
unsigned int arg2 ;
@@ -57744,22 +58169,21 @@
XSRETURN(argvi);
}
-XS(_wrap_SAXParser_setDoNamespaces) {
+XS(_wrap_SAXParser_getExternalSchemaLocation) {
SAXParser *arg1 ;
- bool arg2 ;
int argvi = 0;
+ XMLCh *result ;
dXSARGS;
- if ((items < 2) || (items > 2))
- croak("Usage: SAXParser_setDoNamespaces(self,newState);");
+ if ((items < 1) || (items > 1))
+ croak("Usage: SAXParser_getExternalSchemaLocation(self);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_SAXParser) < 0) {
- croak("Type error in argument 1 of SAXParser_setDoNamespaces. Expected %s", SWIGTYPE_p_SAXParser->name);
+ croak("Type error in argument 1 of SAXParser_getExternalSchemaLocation. Expected %s", SWIGTYPE_p_SAXParser->name);
XSRETURN(1);
}
- arg2 = (bool )SvIV(ST(1));
{
try {
- (arg1)->setDoNamespaces(arg2);
+ result = (XMLCh *)((SAXParser const *)arg1)->getExternalSchemaLocation();
}
catch (const XMLException& e)
@@ -57783,25 +58207,50 @@
XMLPlatformUtils::Terminate();
croak("%s", "Handling Unknown exception");
}
- }XSRETURN(argvi);
+ }{
+ unsigned int charsEaten = 0;
+ int length = XMLString::stringLen(result); // string length
+ XMLByte* res = new XMLByte[length * UTF8_MAXLEN]; // output string
+ unsigned int total_chars =
+ UTF8_TRANSCODER->transcodeTo((const XMLCh*) result,
+ (unsigned int) length,
+ (XMLByte*) res,
+ (unsigned int) length*UTF8_MAXLEN,
+ charsEaten,
+ XMLTranscoder::UnRep_Throw
+ );
+ res[total_chars] = '\0';
+ if (DEBUG_UTF8_OUT) {
+ printf("Xerces out length = %d: ",total_chars);
+ for (int i=0;i<length;i++){
+ printf("<0x%.4X>",res[i]);
+ }
+ printf("\n");
+ }
+ ST(argvi) = sv_newmortal();
+ sv_setpv((SV*)ST(argvi), (char *)res );
+ SvUTF8_on((SV*)ST(argvi));
+ delete[] res;
+ ++argvi;
+ }
+ XSRETURN(argvi);
}
-XS(_wrap_SAXParser_setValidationScheme) {
+XS(_wrap_SAXParser_getExternalNoNamespaceSchemaLocation) {
SAXParser *arg1 ;
- int arg2 ;
int argvi = 0;
+ XMLCh *result ;
dXSARGS;
- if ((items < 2) || (items > 2))
- croak("Usage: SAXParser_setValidationScheme(self,newScheme);");
+ if ((items < 1) || (items > 1))
+ croak("Usage: SAXParser_getExternalNoNamespaceSchemaLocation(self);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_SAXParser) < 0) {
- croak("Type error in argument 1 of SAXParser_setValidationScheme. Expected %s", SWIGTYPE_p_SAXParser->name);
+ croak("Type error in argument 1 of SAXParser_getExternalNoNamespaceSchemaLocation. Expected %s", SWIGTYPE_p_SAXParser->name);
XSRETURN(1);
}
- arg2 = (int )SvIV(ST(1));
{
try {
- (arg1)->setValidationScheme((SAXParser::ValSchemes )arg2);
+ result = (XMLCh *)((SAXParser const *)arg1)->getExternalNoNamespaceSchemaLocation();
}
catch (const XMLException& e)
@@ -57825,7 +58274,117 @@
XMLPlatformUtils::Terminate();
croak("%s", "Handling Unknown exception");
}
- }XSRETURN(argvi);
+ }{
+ unsigned int charsEaten = 0;
+ int length = XMLString::stringLen(result); // string length
+ XMLByte* res = new XMLByte[length * UTF8_MAXLEN]; // output string
+ unsigned int total_chars =
+ UTF8_TRANSCODER->transcodeTo((const XMLCh*) result,
+ (unsigned int) length,
+ (XMLByte*) res,
+ (unsigned int) length*UTF8_MAXLEN,
+ charsEaten,
+ XMLTranscoder::UnRep_Throw
+ );
+ res[total_chars] = '\0';
+ if (DEBUG_UTF8_OUT) {
+ printf("Xerces out length = %d: ",total_chars);
+ for (int i=0;i<length;i++){
+ printf("<0x%.4X>",res[i]);
+ }
+ printf("\n");
+ }
+ ST(argvi) = sv_newmortal();
+ sv_setpv((SV*)ST(argvi), (char *)res );
+ SvUTF8_on((SV*)ST(argvi));
+ delete[] res;
+ ++argvi;
+ }
+ XSRETURN(argvi);
+}
+
+XS(_wrap_SAXParser_setDoNamespaces) {
+ SAXParser *arg1 ;
+ bool arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2))
+ croak("Usage: SAXParser_setDoNamespaces(self,newState);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_SAXParser) < 0) {
+ croak("Type error in argument 1 of SAXParser_setDoNamespaces. Expected %s", SWIGTYPE_p_SAXParser->name);
+ XSRETURN(1);
+ }
+ arg2 = (bool )SvIV(ST(1));
+ {
+ try {
+ (arg1)->setDoNamespaces(arg2);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
+}
+
+XS(_wrap_SAXParser_setValidationScheme) {
+ SAXParser *arg1 ;
+ int arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2))
+ croak("Usage: SAXParser_setValidationScheme(self,newScheme);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_SAXParser) < 0) {
+ croak("Type error in argument 1 of SAXParser_setValidationScheme. Expected %s", SWIGTYPE_p_SAXParser->name);
+ XSRETURN(1);
+ }
+ arg2 = (int )SvIV(ST(1));
+ {
+ try {
+ (arg1)->setValidationScheme((SAXParser::ValSchemes )arg2);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
}
XS(_wrap_SAXParser_setDoSchema) {
@@ -57996,6 +58555,190 @@
}XSRETURN(argvi);
}
+XS(_wrap_SAXParser_setExternalSchemaLocation) {
+ SAXParser *arg1 ;
+ XMLCh *arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2))
+ croak("Usage: SAXParser_setExternalSchemaLocation(self,schemaLocation);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_SAXParser) < 0) {
+ croak("Type error in argument 1 of SAXParser_setExternalSchemaLocation. Expected %s", SWIGTYPE_p_SAXParser->name);
+ XSRETURN(1);
+ }
+ {
+ if (SvPOK(ST(1))||SvIOK(ST(1))||SvNOK(ST(1))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(1),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(1))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg2 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg2,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg2[chars_stored] = '\0';
+ }else {
+ arg2 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg2[i];i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of SAXParser_setExternalSchemaLocation, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ {
+ try {
+ (arg1)->setExternalSchemaLocation((XMLCh const *)arg2);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }{
+ delete[] arg2;
+ }
+ XSRETURN(argvi);
+}
+
+XS(_wrap_SAXParser_setExternalNoNamespaceSchemaLocation) {
+ SAXParser *arg1 ;
+ XMLCh *arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2))
+ croak("Usage: SAXParser_setExternalNoNamespaceSchemaLocation(self,noNamespaceSchemaLocation);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_SAXParser) < 0) {
+ croak("Type error in argument 1 of SAXParser_setExternalNoNamespaceSchemaLocation. Expected %s", SWIGTYPE_p_SAXParser->name);
+ XSRETURN(1);
+ }
+ {
+ if (SvPOK(ST(1))||SvIOK(ST(1))||SvNOK(ST(1))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(1),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(1))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg2 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg2,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg2[chars_stored] = '\0';
+ }else {
+ arg2 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg2[i];i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of SAXParser_setExternalNoNamespaceSchemaLocation, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ {
+ try {
+ (arg1)->setExternalNoNamespaceSchemaLocation((XMLCh const *)arg2);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }{
+ delete[] arg2;
+ }
+ XSRETURN(argvi);
+}
+
XS(_wrap_SAXParser_installAdvDocHandler) {
SAXParser *arg1 ;
XMLDocumentHandler *arg2 ;
@@ -59520,21 +60263,21 @@
XSRETURN(argvi);
}
-XS(_wrap_DOMParser_getExpandEntityReferences) {
+XS(_wrap_DOMParser_getCreateEntityReferenceNodes) {
DOMParser *arg1 ;
int argvi = 0;
bool result ;
dXSARGS;
if ((items < 1) || (items > 1))
- croak("Usage: DOMParser_getExpandEntityReferences(self);");
+ croak("Usage: DOMParser_getCreateEntityReferenceNodes(self);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_getExpandEntityReferences. Expected %s", SWIGTYPE_p_DOMParser->name);
+ croak("Type error in argument 1 of DOMParser_getCreateEntityReferenceNodes. Expected %s", SWIGTYPE_p_DOMParser->name);
XSRETURN(1);
}
{
try {
- result = (bool )((DOMParser const *)arg1)->getExpandEntityReferences();
+ result = (bool )((DOMParser const *)arg1)->getCreateEntityReferenceNodes();
}
catch (const XMLException& e)
@@ -59563,21 +60306,21 @@
XSRETURN(argvi);
}
-XS(_wrap_DOMParser_getCreateEntityReferenceNodes) {
+XS(_wrap_DOMParser_getIncludeIgnorableWhitespace) {
DOMParser *arg1 ;
int argvi = 0;
bool result ;
dXSARGS;
if ((items < 1) || (items > 1))
- croak("Usage: DOMParser_getCreateEntityReferenceNodes(self);");
+ croak("Usage: DOMParser_getIncludeIgnorableWhitespace(self);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_getCreateEntityReferenceNodes. Expected %s", SWIGTYPE_p_DOMParser->name);
+ croak("Type error in argument 1 of DOMParser_getIncludeIgnorableWhitespace. Expected %s", SWIGTYPE_p_DOMParser->name);
XSRETURN(1);
}
{
try {
- result = (bool )((DOMParser const *)arg1)->getCreateEntityReferenceNodes();
+ result = (bool )((DOMParser const *)arg1)->getIncludeIgnorableWhitespace();
}
catch (const XMLException& e)
@@ -59606,21 +60349,21 @@
XSRETURN(argvi);
}
-XS(_wrap_DOMParser_getIncludeIgnorableWhitespace) {
+XS(_wrap_DOMParser_getToCreateXMLDeclTypeNode) {
DOMParser *arg1 ;
int argvi = 0;
bool result ;
dXSARGS;
if ((items < 1) || (items > 1))
- croak("Usage: DOMParser_getIncludeIgnorableWhitespace(self);");
+ croak("Usage: DOMParser_getToCreateXMLDeclTypeNode(self);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_getIncludeIgnorableWhitespace. Expected %s", SWIGTYPE_p_DOMParser->name);
+ croak("Type error in argument 1 of DOMParser_getToCreateXMLDeclTypeNode. Expected %s", SWIGTYPE_p_DOMParser->name);
XSRETURN(1);
}
{
try {
- result = (bool )((DOMParser const *)arg1)->getIncludeIgnorableWhitespace();
+ result = (bool )((DOMParser const *)arg1)->getToCreateXMLDeclTypeNode();
}
catch (const XMLException& e)
@@ -59649,21 +60392,21 @@
XSRETURN(argvi);
}
-XS(_wrap_DOMParser_getToCreateXMLDeclTypeNode) {
+XS(_wrap_DOMParser_getExternalSchemaLocation) {
DOMParser *arg1 ;
int argvi = 0;
- bool result ;
+ XMLCh *result ;
dXSARGS;
if ((items < 1) || (items > 1))
- croak("Usage: DOMParser_getToCreateXMLDeclTypeNode(self);");
+ croak("Usage: DOMParser_getExternalSchemaLocation(self);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_getToCreateXMLDeclTypeNode. Expected %s", SWIGTYPE_p_DOMParser->name);
+ croak("Type error in argument 1 of DOMParser_getExternalSchemaLocation. Expected %s", SWIGTYPE_p_DOMParser->name);
XSRETURN(1);
}
{
try {
- result = (bool )((DOMParser const *)arg1)->getToCreateXMLDeclTypeNode();
+ result = (XMLCh *)((DOMParser const *)arg1)->getExternalSchemaLocation();
}
catch (const XMLException& e)
@@ -59687,30 +60430,50 @@
XMLPlatformUtils::Terminate();
croak("%s", "Handling Unknown exception");
}
- }ST(argvi) = sv_newmortal();
- sv_setiv(ST(argvi++),(IV) result);
+ }{
+ unsigned int charsEaten = 0;
+ int length = XMLString::stringLen(result); // string length
+ XMLByte* res = new XMLByte[length * UTF8_MAXLEN]; // output string
+ unsigned int total_chars =
+ UTF8_TRANSCODER->transcodeTo((const XMLCh*) result,
+ (unsigned int) length,
+ (XMLByte*) res,
+ (unsigned int) length*UTF8_MAXLEN,
+ charsEaten,
+ XMLTranscoder::UnRep_Throw
+ );
+ res[total_chars] = '\0';
+ if (DEBUG_UTF8_OUT) {
+ printf("Xerces out length = %d: ",total_chars);
+ for (int i=0;i<length;i++){
+ printf("<0x%.4X>",res[i]);
+ }
+ printf("\n");
+ }
+ ST(argvi) = sv_newmortal();
+ sv_setpv((SV*)ST(argvi), (char *)res );
+ SvUTF8_on((SV*)ST(argvi));
+ delete[] res;
+ ++argvi;
+ }
XSRETURN(argvi);
}
-XS(_wrap_DOMParser_setErrorHandler) {
+XS(_wrap_DOMParser_getExternalNoNamespaceSchemaLocation) {
DOMParser *arg1 ;
- ErrorHandler *arg2 ;
int argvi = 0;
+ XMLCh *result ;
dXSARGS;
- if ((items < 2) || (items > 2))
- croak("Usage: DOMParser_setErrorHandler(self,handler);");
+ if ((items < 1) || (items > 1))
+ croak("Usage: DOMParser_getExternalNoNamespaceSchemaLocation(self);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_setErrorHandler. Expected %s", SWIGTYPE_p_DOMParser->name);
- XSRETURN(1);
- }
- if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_ErrorHandler) < 0) {
- croak("Type error in argument 2 of DOMParser_setErrorHandler. Expected %s", SWIGTYPE_p_ErrorHandler->name);
+ croak("Type error in argument 1 of DOMParser_getExternalNoNamespaceSchemaLocation. Expected %s", SWIGTYPE_p_DOMParser->name);
XSRETURN(1);
}
{
try {
- (arg1)->setErrorHandler(arg2);
+ result = (XMLCh *)((DOMParser const *)arg1)->getExternalNoNamespaceSchemaLocation();
}
catch (const XMLException& e)
@@ -59734,28 +60497,54 @@
XMLPlatformUtils::Terminate();
croak("%s", "Handling Unknown exception");
}
- }XSRETURN(argvi);
+ }{
+ unsigned int charsEaten = 0;
+ int length = XMLString::stringLen(result); // string length
+ XMLByte* res = new XMLByte[length * UTF8_MAXLEN]; // output string
+ unsigned int total_chars =
+ UTF8_TRANSCODER->transcodeTo((const XMLCh*) result,
+ (unsigned int) length,
+ (XMLByte*) res,
+ (unsigned int) length*UTF8_MAXLEN,
+ charsEaten,
+ XMLTranscoder::UnRep_Throw
+ );
+ res[total_chars] = '\0';
+ if (DEBUG_UTF8_OUT) {
+ printf("Xerces out length = %d: ",total_chars);
+ for (int i=0;i<length;i++){
+ printf("<0x%.4X>",res[i]);
+ }
+ printf("\n");
+ }
+ ST(argvi) = sv_newmortal();
+ sv_setpv((SV*)ST(argvi), (char *)res );
+ SvUTF8_on((SV*)ST(argvi));
+ delete[] res;
+ ++argvi;
+ }
+ XSRETURN(argvi);
}
-XS(_wrap_DOMParser_setEntityResolver) {
+XS(_wrap_DOMParser_setErrorHandler) {
DOMParser *arg1 ;
- EntityResolver *arg2 ;
+ ErrorHandler *arg2 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2))
- croak("Usage: DOMParser_setEntityResolver(self,handler);");
+ croak("Usage: DOMParser_setErrorHandler(self,handler);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_setEntityResolver. Expected %s", SWIGTYPE_p_DOMParser->name);
+ croak("Type error in argument 1 of DOMParser_setErrorHandler. Expected %s", SWIGTYPE_p_DOMParser->name);
XSRETURN(1);
}
- if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_EntityResolver) < 0) {
- croak("Type error in argument 2 of DOMParser_setEntityResolver. Expected %s", SWIGTYPE_p_EntityResolver->name);
+ if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_ErrorHandler) < 0) {
+ croak("Type error in argument 2 of DOMParser_setErrorHandler. Expected %s", SWIGTYPE_p_ErrorHandler->name);
XSRETURN(1);
}
{
try {
- (arg1)->setEntityResolver(arg2);
+ (arg1)->setErrorHandler(arg2);
}
catch (const XMLException& e)
@@ -59782,22 +60571,25 @@
}XSRETURN(argvi);
}
-XS(_wrap_DOMParser_setDoNamespaces) {
+XS(_wrap_DOMParser_setEntityResolver) {
DOMParser *arg1 ;
- bool arg2 ;
+ EntityResolver *arg2 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2))
- croak("Usage: DOMParser_setDoNamespaces(self,newState);");
+ croak("Usage: DOMParser_setEntityResolver(self,handler);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_setDoNamespaces. Expected %s", SWIGTYPE_p_DOMParser->name);
+ croak("Type error in argument 1 of DOMParser_setEntityResolver. Expected %s", SWIGTYPE_p_DOMParser->name);
+ XSRETURN(1);
+ }
+ if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_EntityResolver) < 0) {
+ croak("Type error in argument 2 of DOMParser_setEntityResolver. Expected %s", SWIGTYPE_p_EntityResolver->name);
XSRETURN(1);
}
- arg2 = (bool )SvIV(ST(1));
{
try {
- (arg1)->setDoNamespaces(arg2);
+ (arg1)->setEntityResolver(arg2);
}
catch (const XMLException& e)
@@ -59824,22 +60616,22 @@
}XSRETURN(argvi);
}
-XS(_wrap_DOMParser_setExitOnFirstFatalError) {
+XS(_wrap_DOMParser_setDoNamespaces) {
DOMParser *arg1 ;
bool arg2 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2))
- croak("Usage: DOMParser_setExitOnFirstFatalError(self,newState);");
+ croak("Usage: DOMParser_setDoNamespaces(self,newState);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_setExitOnFirstFatalError. Expected %s", SWIGTYPE_p_DOMParser->name);
+ croak("Type error in argument 1 of DOMParser_setDoNamespaces. Expected %s", SWIGTYPE_p_DOMParser->name);
XSRETURN(1);
}
arg2 = (bool )SvIV(ST(1));
{
try {
- (arg1)->setExitOnFirstFatalError(arg2);
+ (arg1)->setDoNamespaces(arg2);
}
catch (const XMLException& e)
@@ -59866,22 +60658,22 @@
}XSRETURN(argvi);
}
-XS(_wrap_DOMParser_setValidationConstraintFatal) {
+XS(_wrap_DOMParser_setExitOnFirstFatalError) {
DOMParser *arg1 ;
bool arg2 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2))
- croak("Usage: DOMParser_setValidationConstraintFatal(self,newState);");
+ croak("Usage: DOMParser_setExitOnFirstFatalError(self,newState);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_setValidationConstraintFatal. Expected %s", SWIGTYPE_p_DOMParser->name);
+ croak("Type error in argument 1 of DOMParser_setExitOnFirstFatalError. Expected %s", SWIGTYPE_p_DOMParser->name);
XSRETURN(1);
}
arg2 = (bool )SvIV(ST(1));
{
try {
- (arg1)->setValidationConstraintFatal(arg2);
+ (arg1)->setExitOnFirstFatalError(arg2);
}
catch (const XMLException& e)
@@ -59908,22 +60700,22 @@
}XSRETURN(argvi);
}
-XS(_wrap_DOMParser_setExpandEntityReferences) {
+XS(_wrap_DOMParser_setValidationConstraintFatal) {
DOMParser *arg1 ;
bool arg2 ;
int argvi = 0;
dXSARGS;
if ((items < 2) || (items > 2))
- croak("Usage: DOMParser_setExpandEntityReferences(self,expand);");
+ croak("Usage: DOMParser_setValidationConstraintFatal(self,newState);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_setExpandEntityReferences. Expected %s", SWIGTYPE_p_DOMParser->name);
+ croak("Type error in argument 1 of DOMParser_setValidationConstraintFatal. Expected %s", SWIGTYPE_p_DOMParser->name);
XSRETURN(1);
}
arg2 = (bool )SvIV(ST(1));
{
try {
- (arg1)->setExpandEntityReferences(arg2);
+ (arg1)->setValidationConstraintFatal(arg2);
}
catch (const XMLException& e)
@@ -60202,29 +60994,69 @@
}XSRETURN(argvi);
}
-XS(_wrap_DOMParser_parse__overload__is) {
+XS(_wrap_DOMParser_setExternalSchemaLocation) {
DOMParser *arg1 ;
- InputSource *arg2 ;
- bool arg3 = false ;
+ XMLCh *arg2 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 3))
- croak("Usage: DOMParser_parse__overload__is(self,source,reuseGrammar);");
+ if ((items < 2) || (items > 2))
+ croak("Usage: DOMParser_setExternalSchemaLocation(self,schemaLocation);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_parse__overload__is. Expected %s", SWIGTYPE_p_DOMParser->name);
- XSRETURN(1);
- }
- if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_InputSource) < 0) {
- croak("Type error in argument 2 of DOMParser_parse__overload__is. Expected %s", SWIGTYPE_p_InputSource->name);
+ croak("Type error in argument 1 of DOMParser_setExternalSchemaLocation. Expected %s", SWIGTYPE_p_DOMParser->name);
XSRETURN(1);
}
- if (items > 2) {
- arg3 = (bool )SvIV(ST(2));
+ {
+ if (SvPOK(ST(1))||SvIOK(ST(1))||SvNOK(ST(1))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(1),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(1))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg2 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg2,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg2[chars_stored] = '\0';
+ }else {
+ arg2 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg2[i];i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of DOMParser_setExternalSchemaLocation, Expected perl-string.");
+ XSRETURN(1);
+ }
}
{
try {
- (arg1)->parse((InputSource const &)*arg2,arg3);
+ (arg1)->setExternalSchemaLocation((XMLCh const *)arg2);
}
catch (const XMLException& e)
@@ -60248,24 +61080,168 @@
XMLPlatformUtils::Terminate();
croak("%s", "Handling Unknown exception");
}
- }XSRETURN(argvi);
+ }{
+ delete[] arg2;
+ }
+ XSRETURN(argvi);
}
-XS(_wrap_DOMParser_parse) {
+XS(_wrap_DOMParser_setExternalNoNamespaceSchemaLocation) {
DOMParser *arg1 ;
- char *arg2 ;
- bool arg3 = false ;
+ XMLCh *arg2 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 3))
- croak("Usage: DOMParser_parse(self,systemId,reuseGrammar);");
+ if ((items < 2) || (items > 2))
+ croak("Usage: DOMParser_setExternalNoNamespaceSchemaLocation(self,noNamespaceSchemaLocation);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
- croak("Type error in argument 1 of DOMParser_parse. Expected %s", SWIGTYPE_p_DOMParser->name);
+ croak("Type error in argument 1 of DOMParser_setExternalNoNamespaceSchemaLocation. Expected %s", SWIGTYPE_p_DOMParser->name);
XSRETURN(1);
}
- if (! SvOK((SV*) ST(1))) {
- arg2 = 0;
+ {
+ if (SvPOK(ST(1))||SvIOK(ST(1))||SvNOK(ST(1))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(1),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(1))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg2 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg2,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg2[chars_stored] = '\0';
+ }else {
+ arg2 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg2[i];i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of DOMParser_setExternalNoNamespaceSchemaLocation, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ {
+ try {
+ (arg1)->setExternalNoNamespaceSchemaLocation((XMLCh const *)arg2);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }{
+ delete[] arg2;
+ }
+ XSRETURN(argvi);
+}
+
+XS(_wrap_DOMParser_parse__overload__is) {
+ DOMParser *arg1 ;
+ InputSource *arg2 ;
+ bool arg3 = false ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 3))
+ croak("Usage: DOMParser_parse__overload__is(self,source,reuseGrammar);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
+ croak("Type error in argument 1 of DOMParser_parse__overload__is. Expected %s", SWIGTYPE_p_DOMParser->name);
+ XSRETURN(1);
+ }
+ if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_InputSource) < 0) {
+ croak("Type error in argument 2 of DOMParser_parse__overload__is. Expected %s", SWIGTYPE_p_InputSource->name);
+ XSRETURN(1);
+ }
+ if (items > 2) {
+ arg3 = (bool )SvIV(ST(2));
+ }
+ {
+ try {
+ (arg1)->parse((InputSource const &)*arg2,arg3);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
+}
+
+XS(_wrap_DOMParser_parse) {
+ DOMParser *arg1 ;
+ char *arg2 ;
+ bool arg3 = false ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 3))
+ croak("Usage: DOMParser_parse(self,systemId,reuseGrammar);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
+ croak("Type error in argument 1 of DOMParser_parse. Expected %s", SWIGTYPE_p_DOMParser->name);
+ XSRETURN(1);
+ }
+ if (! SvOK((SV*) ST(1))) {
+ arg2 = 0;
}
else {
arg2 = (char *) SvPV(ST(1),PL_na);
@@ -60810,6 +61786,91 @@
}XSRETURN(argvi);
}
+XS(_wrap_DOMParser_setExpandEntityReferences) {
+ DOMParser *arg1 ;
+ bool arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2))
+ croak("Usage: DOMParser_setExpandEntityReferences(self,expand);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
+ croak("Type error in argument 1 of DOMParser_setExpandEntityReferences. Expected %s", SWIGTYPE_p_DOMParser->name);
+ XSRETURN(1);
+ }
+ arg2 = (bool )SvIV(ST(1));
+ {
+ try {
+ (arg1)->setExpandEntityReferences(arg2);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
+}
+
+XS(_wrap_DOMParser_getExpandEntityReferences) {
+ DOMParser *arg1 ;
+ int argvi = 0;
+ bool result ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1))
+ croak("Usage: DOMParser_getExpandEntityReferences(self);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_DOMParser) < 0) {
+ croak("Type error in argument 1 of DOMParser_getExpandEntityReferences. Expected %s", SWIGTYPE_p_DOMParser->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ result = (bool )((DOMParser const *)arg1)->getExpandEntityReferences();
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++),(IV) result);
+ XSRETURN(argvi);
+}
+
XS(_wrap_new_IDOMParser) {
XMLValidator *arg1 = 0 ;
int argvi = 0;
@@ -61578,6 +62639,140 @@
XSRETURN(argvi);
}
+XS(_wrap_IDOMParser_getExternalSchemaLocation) {
+ IDOMParser *arg1 ;
+ int argvi = 0;
+ XMLCh *result ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1))
+ croak("Usage: IDOMParser_getExternalSchemaLocation(self);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
+ croak("Type error in argument 1 of IDOMParser_getExternalSchemaLocation. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ result = (XMLCh *)((IDOMParser const *)arg1)->getExternalSchemaLocation();
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }{
+ unsigned int charsEaten = 0;
+ int length = XMLString::stringLen(result); // string length
+ XMLByte* res = new XMLByte[length * UTF8_MAXLEN]; // output string
+ unsigned int total_chars =
+ UTF8_TRANSCODER->transcodeTo((const XMLCh*) result,
+ (unsigned int) length,
+ (XMLByte*) res,
+ (unsigned int) length*UTF8_MAXLEN,
+ charsEaten,
+ XMLTranscoder::UnRep_Throw
+ );
+ res[total_chars] = '\0';
+ if (DEBUG_UTF8_OUT) {
+ printf("Xerces out length = %d: ",total_chars);
+ for (int i=0;i<length;i++){
+ printf("<0x%.4X>",res[i]);
+ }
+ printf("\n");
+ }
+ ST(argvi) = sv_newmortal();
+ sv_setpv((SV*)ST(argvi), (char *)res );
+ SvUTF8_on((SV*)ST(argvi));
+ delete[] res;
+ ++argvi;
+ }
+ XSRETURN(argvi);
+}
+
+XS(_wrap_IDOMParser_getExternalNoNamespaceSchemaLocation) {
+ IDOMParser *arg1 ;
+ int argvi = 0;
+ XMLCh *result ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1))
+ croak("Usage: IDOMParser_getExternalNoNamespaceSchemaLocation(self);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
+ croak("Type error in argument 1 of IDOMParser_getExternalNoNamespaceSchemaLocation. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ result = (XMLCh *)((IDOMParser const *)arg1)->getExternalNoNamespaceSchemaLocation();
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }{
+ unsigned int charsEaten = 0;
+ int length = XMLString::stringLen(result); // string length
+ XMLByte* res = new XMLByte[length * UTF8_MAXLEN]; // output string
+ unsigned int total_chars =
+ UTF8_TRANSCODER->transcodeTo((const XMLCh*) result,
+ (unsigned int) length,
+ (XMLByte*) res,
+ (unsigned int) length*UTF8_MAXLEN,
+ charsEaten,
+ XMLTranscoder::UnRep_Throw
+ );
+ res[total_chars] = '\0';
+ if (DEBUG_UTF8_OUT) {
+ printf("Xerces out length = %d: ",total_chars);
+ for (int i=0;i<length;i++){
+ printf("<0x%.4X>",res[i]);
+ }
+ printf("\n");
+ }
+ ST(argvi) = sv_newmortal();
+ sv_setpv((SV*)ST(argvi), (char *)res );
+ SvUTF8_on((SV*)ST(argvi));
+ delete[] res;
+ ++argvi;
+ }
+ XSRETURN(argvi);
+}
+
XS(_wrap_IDOMParser_setErrorHandler) {
IDOMParser *arg1 ;
ErrorHandler *arg2 ;
@@ -62046,29 +63241,69 @@
}XSRETURN(argvi);
}
-XS(_wrap_IDOMParser_parse__overload__is) {
+XS(_wrap_IDOMParser_setExternalSchemaLocation) {
IDOMParser *arg1 ;
- InputSource *arg2 ;
- bool arg3 = false ;
+ XMLCh *arg2 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 3))
- croak("Usage: IDOMParser_parse__overload__is(self,source,reuseGrammar);");
+ if ((items < 2) || (items > 2))
+ croak("Usage: IDOMParser_setExternalSchemaLocation(self,schemaLocation);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
- croak("Type error in argument 1 of IDOMParser_parse__overload__is. Expected %s", SWIGTYPE_p_IDOMParser->name);
- XSRETURN(1);
- }
- if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_InputSource) < 0) {
- croak("Type error in argument 2 of IDOMParser_parse__overload__is. Expected %s", SWIGTYPE_p_InputSource->name);
+ croak("Type error in argument 1 of IDOMParser_setExternalSchemaLocation. Expected %s", SWIGTYPE_p_IDOMParser->name);
XSRETURN(1);
}
- if (items > 2) {
- arg3 = (bool )SvIV(ST(2));
+ {
+ if (SvPOK(ST(1))||SvIOK(ST(1))||SvNOK(ST(1))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(1),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(1))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg2 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg2,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg2[chars_stored] = '\0';
+ }else {
+ arg2 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg2[i];i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of IDOMParser_setExternalSchemaLocation, Expected perl-string.");
+ XSRETURN(1);
+ }
}
{
try {
- (arg1)->parse((InputSource const &)*arg2,arg3);
+ (arg1)->setExternalSchemaLocation((XMLCh const *)arg2);
}
catch (const XMLException& e)
@@ -62092,34 +63327,75 @@
XMLPlatformUtils::Terminate();
croak("%s", "Handling Unknown exception");
}
- }XSRETURN(argvi);
+ }{
+ delete[] arg2;
+ }
+ XSRETURN(argvi);
}
-XS(_wrap_IDOMParser_parse) {
+XS(_wrap_IDOMParser_setExternalNoNamespaceSchemaLocation) {
IDOMParser *arg1 ;
- char *arg2 ;
- bool arg3 = false ;
+ XMLCh *arg2 ;
int argvi = 0;
dXSARGS;
- if ((items < 2) || (items > 3))
- croak("Usage: IDOMParser_parse(self,systemId,reuseGrammar);");
+ if ((items < 2) || (items > 2))
+ croak("Usage: IDOMParser_setExternalNoNamespaceSchemaLocation(self,noNamespaceSchemaLocation);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
- croak("Type error in argument 1 of IDOMParser_parse. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ croak("Type error in argument 1 of IDOMParser_setExternalNoNamespaceSchemaLocation. Expected %s", SWIGTYPE_p_IDOMParser->name);
XSRETURN(1);
}
- if (! SvOK((SV*) ST(1))) {
- arg2 = 0;
- }
- else {
- arg2 = (char *) SvPV(ST(1),PL_na);
- }
- if (items > 2) {
- arg3 = (bool )SvIV(ST(2));
+ {
+ if (SvPOK(ST(1))||SvIOK(ST(1))||SvNOK(ST(1))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(1),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(1))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg2 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg2,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg2[chars_stored] = '\0';
+ }else {
+ arg2 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg2[i];i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of IDOMParser_setExternalNoNamespaceSchemaLocation, Expected perl-string.");
+ XSRETURN(1);
+ }
}
{
try {
- (arg1)->parse((char const *)arg2,arg3);
+ (arg1)->setExternalNoNamespaceSchemaLocation((XMLCh const *)arg2);
}
catch (const XMLException& e)
@@ -62143,40 +63419,941 @@
XMLPlatformUtils::Terminate();
croak("%s", "Handling Unknown exception");
}
- }XSRETURN(argvi);
+ }{
+ delete[] arg2;
+ }
+ XSRETURN(argvi);
}
-XS(_wrap_IDOMParser_parseFirst) {
+XS(_wrap_IDOMParser_parse__overload__is) {
IDOMParser *arg1 ;
- char *arg2 ;
- XMLPScanToken *arg3 ;
- bool arg4 = false ;
+ InputSource *arg2 ;
+ bool arg3 = false ;
int argvi = 0;
- bool result ;
dXSARGS;
- if ((items < 3) || (items > 4))
- croak("Usage: IDOMParser_parseFirst(self,systemId,toFill,reuseGrammar);");
+ if ((items < 2) || (items > 3))
+ croak("Usage: IDOMParser_parse__overload__is(self,source,reuseGrammar);");
if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
- croak("Type error in argument 1 of IDOMParser_parseFirst. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ croak("Type error in argument 1 of IDOMParser_parse__overload__is. Expected %s", SWIGTYPE_p_IDOMParser->name);
XSRETURN(1);
}
- if (! SvOK((SV*) ST(1))) {
- arg2 = 0;
+ if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_InputSource) < 0) {
+ croak("Type error in argument 2 of IDOMParser_parse__overload__is. Expected %s", SWIGTYPE_p_InputSource->name);
+ XSRETURN(1);
}
- else {
- arg2 = (char *) SvPV(ST(1),PL_na);
+ if (items > 2) {
+ arg3 = (bool )SvIV(ST(2));
+ }
+ {
+ try {
+ (arg1)->parse((InputSource const &)*arg2,arg3);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
+}
+
+XS(_wrap_IDOMParser_parse) {
+ IDOMParser *arg1 ;
+ char *arg2 ;
+ bool arg3 = false ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 3))
+ croak("Usage: IDOMParser_parse(self,systemId,reuseGrammar);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
+ croak("Type error in argument 1 of IDOMParser_parse. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ XSRETURN(1);
+ }
+ if (! SvOK((SV*) ST(1))) {
+ arg2 = 0;
+ }
+ else {
+ arg2 = (char *) SvPV(ST(1),PL_na);
+ }
+ if (items > 2) {
+ arg3 = (bool )SvIV(ST(2));
+ }
+ {
+ try {
+ (arg1)->parse((char const *)arg2,arg3);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
+}
+
+XS(_wrap_IDOMParser_parseFirst) {
+ IDOMParser *arg1 ;
+ char *arg2 ;
+ XMLPScanToken *arg3 ;
+ bool arg4 = false ;
+ int argvi = 0;
+ bool result ;
+ dXSARGS;
+
+ if ((items < 3) || (items > 4))
+ croak("Usage: IDOMParser_parseFirst(self,systemId,toFill,reuseGrammar);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
+ croak("Type error in argument 1 of IDOMParser_parseFirst. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ XSRETURN(1);
+ }
+ if (! SvOK((SV*) ST(1))) {
+ arg2 = 0;
+ }
+ else {
+ arg2 = (char *) SvPV(ST(1),PL_na);
+ }
+ if (SWIG_ConvertPtr(ST(2),(void **) &arg3,SWIGTYPE_p_XMLPScanToken) < 0) {
+ croak("Type error in argument 3 of IDOMParser_parseFirst. Expected %s", SWIGTYPE_p_XMLPScanToken->name);
+ XSRETURN(1);
+ }
+ if (items > 3) {
+ arg4 = (bool )SvIV(ST(3));
+ }
+ {
+ try {
+ result = (bool )(arg1)->parseFirst((char const *)arg2,*arg3,arg4);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++),(IV) result);
+ XSRETURN(argvi);
+}
+
+XS(_wrap_IDOMParser_parseFirst__overload__is) {
+ IDOMParser *arg1 ;
+ InputSource *arg2 ;
+ XMLPScanToken *arg3 ;
+ bool arg4 = false ;
+ int argvi = 0;
+ bool result ;
+ dXSARGS;
+
+ if ((items < 3) || (items > 4))
+ croak("Usage: IDOMParser_parseFirst__overload__is(self,source,toFill,reuseGrammar);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
+ croak("Type error in argument 1 of IDOMParser_parseFirst__overload__is. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ XSRETURN(1);
+ }
+ if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_InputSource) < 0) {
+ croak("Type error in argument 2 of IDOMParser_parseFirst__overload__is. Expected %s", SWIGTYPE_p_InputSource->name);
+ XSRETURN(1);
+ }
+ if (SWIG_ConvertPtr(ST(2),(void **) &arg3,SWIGTYPE_p_XMLPScanToken) < 0) {
+ croak("Type error in argument 3 of IDOMParser_parseFirst__overload__is. Expected %s", SWIGTYPE_p_XMLPScanToken->name);
+ XSRETURN(1);
+ }
+ if (items > 3) {
+ arg4 = (bool )SvIV(ST(3));
+ }
+ {
+ try {
+ result = (bool )(arg1)->parseFirst((InputSource const &)*arg2,*arg3,arg4);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++),(IV) result);
+ XSRETURN(argvi);
+}
+
+XS(_wrap_IDOMParser_parseNext) {
+ IDOMParser *arg1 ;
+ XMLPScanToken *arg2 ;
+ int argvi = 0;
+ bool result ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2))
+ croak("Usage: IDOMParser_parseNext(self,token);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
+ croak("Type error in argument 1 of IDOMParser_parseNext. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ XSRETURN(1);
+ }
+ if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_XMLPScanToken) < 0) {
+ croak("Type error in argument 2 of IDOMParser_parseNext. Expected %s", SWIGTYPE_p_XMLPScanToken->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ result = (bool )(arg1)->parseNext(*arg2);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++),(IV) result);
+ XSRETURN(argvi);
+}
+
+XS(_wrap_IDOMParser_parseReset) {
+ IDOMParser *arg1 ;
+ XMLPScanToken *arg2 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2))
+ croak("Usage: IDOMParser_parseReset(self,token);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
+ croak("Type error in argument 1 of IDOMParser_parseReset. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ XSRETURN(1);
+ }
+ if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_XMLPScanToken) < 0) {
+ croak("Type error in argument 2 of IDOMParser_parseReset. Expected %s", SWIGTYPE_p_XMLPScanToken->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ (arg1)->parseReset(*arg2);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
+}
+
+XS(_wrap_IDOMParser_error) {
+ IDOMParser *arg1 ;
+ unsigned int arg2 ;
+ XMLCh *arg3 ;
+ XMLErrorReporter::ErrTypes *arg4 ;
+ XMLCh *arg5 ;
+ XMLCh *arg6 ;
+ XMLCh *arg7 ;
+ unsigned int arg8 ;
+ unsigned int arg9 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 9) || (items > 9))
+ croak("Usage: IDOMParser_error(self,errCode,msgDomain,errType,errorText,systemId,publicId,lineNum,colNum);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
+ croak("Type error in argument 1 of IDOMParser_error. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ XSRETURN(1);
+ }
+ arg2 = (unsigned int )SvIV(ST(1));
+ {
+ if (SvPOK(ST(2))||SvIOK(ST(2))||SvNOK(ST(2))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(2),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(2))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg3 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg3,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg3[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg3[chars_stored] = '\0';
+ }else {
+ arg3 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg3[i];i++){
+ printf("<0x%.4X>",arg3[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of IDOMParser_error, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ if (SWIG_ConvertPtr(ST(3),(void **) &arg4,SWIGTYPE_p_XMLErrorReporter__ErrTypes) < 0) {
+ croak("Type error in argument 4 of IDOMParser_error. Expected %s", SWIGTYPE_p_XMLErrorReporter__ErrTypes->name);
+ XSRETURN(1);
+ }
+ {
+ if (SvPOK(ST(4))||SvIOK(ST(4))||SvNOK(ST(4))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(4),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(4))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg5 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg5,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg5[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg5[chars_stored] = '\0';
+ }else {
+ arg5 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg5[i];i++){
+ printf("<0x%.4X>",arg5[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of IDOMParser_error, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ {
+ if (SvPOK(ST(5))||SvIOK(ST(5))||SvNOK(ST(5))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(5),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(5))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg6 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg6,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg6[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg6[chars_stored] = '\0';
+ }else {
+ arg6 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg6[i];i++){
+ printf("<0x%.4X>",arg6[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of IDOMParser_error, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ {
+ if (SvPOK(ST(6))||SvIOK(ST(6))||SvNOK(ST(6))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(6),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(6))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg7 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg7,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg7[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg7[chars_stored] = '\0';
+ }else {
+ arg7 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg7[i];i++){
+ printf("<0x%.4X>",arg7[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of IDOMParser_error, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ arg8 = (unsigned int )SvIV(ST(7));
+ arg9 = (unsigned int )SvIV(ST(8));
+ {
+ try {
+ (arg1)->error(arg2,(XMLCh const *)arg3,*arg4,(XMLCh const *)arg5,(XMLCh const *)arg6,(XMLCh const *)arg7,arg8,arg9);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }{
+ delete[] arg3;
+ }
+ {
+ delete[] arg5;
+ }
+ {
+ delete[] arg6;
+ }
+ {
+ delete[] arg7;
+ }
+ XSRETURN(argvi);
+}
+
+XS(_wrap_IDOMParser_resetErrors) {
+ IDOMParser *arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1))
+ croak("Usage: IDOMParser_resetErrors(self);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
+ croak("Type error in argument 1 of IDOMParser_resetErrors. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ (arg1)->resetErrors();
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
+}
+
+XS(_wrap_delete_Grammar) {
+ Grammar *arg1 ;
+ int argvi = 0;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1))
+ croak("Usage: delete_Grammar(self);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_Grammar) < 0) {
+ croak("Type error in argument 1 of delete_Grammar. Expected %s", SWIGTYPE_p_Grammar->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ delete arg1;
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }XSRETURN(argvi);
+}
+
+XS(_wrap_Grammar_getGrammarType) {
+ Grammar *arg1 ;
+ int argvi = 0;
+ int result ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1))
+ croak("Usage: Grammar_getGrammarType(self);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_Grammar) < 0) {
+ croak("Type error in argument 1 of Grammar_getGrammarType. Expected %s", SWIGTYPE_p_Grammar->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ result = (int )(arg1)->getGrammarType();
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++),(IV) result);
+ XSRETURN(argvi);
+}
+
+XS(_wrap_Grammar_getTargetNamespace) {
+ Grammar *arg1 ;
+ int argvi = 0;
+ XMLCh *result ;
+ dXSARGS;
+
+ if ((items < 1) || (items > 1))
+ croak("Usage: Grammar_getTargetNamespace(self);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_Grammar) < 0) {
+ croak("Type error in argument 1 of Grammar_getTargetNamespace. Expected %s", SWIGTYPE_p_Grammar->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ result = (XMLCh *)((Grammar const *)arg1)->getTargetNamespace();
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }{
+ unsigned int charsEaten = 0;
+ int length = XMLString::stringLen(result); // string length
+ XMLByte* res = new XMLByte[length * UTF8_MAXLEN]; // output string
+ unsigned int total_chars =
+ UTF8_TRANSCODER->transcodeTo((const XMLCh*) result,
+ (unsigned int) length,
+ (XMLByte*) res,
+ (unsigned int) length*UTF8_MAXLEN,
+ charsEaten,
+ XMLTranscoder::UnRep_Throw
+ );
+ res[total_chars] = '\0';
+ if (DEBUG_UTF8_OUT) {
+ printf("Xerces out length = %d: ",total_chars);
+ for (int i=0;i<length;i++){
+ printf("<0x%.4X>",res[i]);
+ }
+ printf("\n");
+ }
+ ST(argvi) = sv_newmortal();
+ sv_setpv((SV*)ST(argvi), (char *)res );
+ SvUTF8_on((SV*)ST(argvi));
+ delete[] res;
+ ++argvi;
+ }
+ XSRETURN(argvi);
+}
+
+XS(_wrap_Grammar_findOrAddElemDecl) {
+ Grammar *arg1 ;
+ unsigned int arg2 ;
+ XMLCh *arg3 ;
+ XMLCh *arg4 ;
+ XMLCh *arg5 ;
+ unsigned int arg6 ;
+ bool *arg7 ;
+ int argvi = 0;
+ XMLElementDecl *result ;
+ dXSARGS;
+
+ if ((items < 7) || (items > 7))
+ croak("Usage: Grammar_findOrAddElemDecl(self,uriId,baseName,prefixName,qName,scope,wasAdded);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_Grammar) < 0) {
+ croak("Type error in argument 1 of Grammar_findOrAddElemDecl. Expected %s", SWIGTYPE_p_Grammar->name);
+ XSRETURN(1);
+ }
+ arg2 = (unsigned int )SvIV(ST(1));
+ {
+ if (SvPOK(ST(2))||SvIOK(ST(2))||SvNOK(ST(2))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(2),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(2))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg3 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg3,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg3[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg3[chars_stored] = '\0';
+ }else {
+ arg3 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg3[i];i++){
+ printf("<0x%.4X>",arg3[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of Grammar_findOrAddElemDecl, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ {
+ if (SvPOK(ST(3))||SvIOK(ST(3))||SvNOK(ST(3))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(3),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(3))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg4 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg4,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg4[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg4[chars_stored] = '\0';
+ }else {
+ arg4 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg4[i];i++){
+ printf("<0x%.4X>",arg4[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of Grammar_findOrAddElemDecl, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ {
+ if (SvPOK(ST(4))||SvIOK(ST(4))||SvNOK(ST(4))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(4),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(4))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg5 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg5,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg5[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg5[chars_stored] = '\0';
+ }else {
+ arg5 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg5[i];i++){
+ printf("<0x%.4X>",arg5[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of Grammar_findOrAddElemDecl, Expected perl-string.");
+ XSRETURN(1);
+ }
}
- if (SWIG_ConvertPtr(ST(2),(void **) &arg3,SWIGTYPE_p_XMLPScanToken) < 0) {
- croak("Type error in argument 3 of IDOMParser_parseFirst. Expected %s", SWIGTYPE_p_XMLPScanToken->name);
+ arg6 = (unsigned int )SvIV(ST(5));
+ if (SWIG_ConvertPtr(ST(6),(void **) &arg7,SWIGTYPE_p_bool) < 0) {
+ croak("Type error in argument 7 of Grammar_findOrAddElemDecl. Expected %s", SWIGTYPE_p_bool->name);
XSRETURN(1);
}
- if (items > 3) {
- arg4 = (bool )SvIV(ST(3));
- }
{
try {
- result = (bool )(arg1)->parseFirst((char const *)arg2,*arg3,arg4);
+ result = (XMLElementDecl *)(arg1)->findOrAddElemDecl(arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5,arg6,*arg7);
}
catch (const XMLException& e)
@@ -62201,39 +64378,136 @@
croak("%s", "Handling Unknown exception");
}
}ST(argvi) = sv_newmortal();
- sv_setiv(ST(argvi++),(IV) result);
+ SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_XMLElementDecl);
+ {
+ delete[] arg3;
+ }
+ {
+ delete[] arg4;
+ }
+ {
+ delete[] arg5;
+ }
XSRETURN(argvi);
}
-XS(_wrap_IDOMParser_parseFirst__overload__is) {
- IDOMParser *arg1 ;
- InputSource *arg2 ;
- XMLPScanToken *arg3 ;
- bool arg4 = false ;
+XS(_wrap_Grammar_getElemId) {
+ Grammar *arg1 ;
+ unsigned int arg2 ;
+ XMLCh *arg3 ;
+ XMLCh *arg4 ;
+ unsigned int arg5 ;
int argvi = 0;
- bool result ;
+ unsigned int result ;
dXSARGS;
- if ((items < 3) || (items > 4))
- croak("Usage: IDOMParser_parseFirst__overload__is(self,source,toFill,reuseGrammar);");
- if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
- croak("Type error in argument 1 of IDOMParser_parseFirst__overload__is. Expected %s", SWIGTYPE_p_IDOMParser->name);
- XSRETURN(1);
- }
- if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_InputSource) < 0) {
- croak("Type error in argument 2 of IDOMParser_parseFirst__overload__is. Expected %s", SWIGTYPE_p_InputSource->name);
+ if ((items < 5) || (items > 5))
+ croak("Usage: Grammar_getElemId(self,uriId,baseName,qName,scope);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_Grammar) < 0) {
+ croak("Type error in argument 1 of Grammar_getElemId. Expected %s", SWIGTYPE_p_Grammar->name);
XSRETURN(1);
}
- if (SWIG_ConvertPtr(ST(2),(void **) &arg3,SWIGTYPE_p_XMLPScanToken) < 0) {
- croak("Type error in argument 3 of IDOMParser_parseFirst__overload__is. Expected %s", SWIGTYPE_p_XMLPScanToken->name);
- XSRETURN(1);
+ arg2 = (unsigned int )SvIV(ST(1));
+ {
+ if (SvPOK(ST(2))||SvIOK(ST(2))||SvNOK(ST(2))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(2),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(2))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg3 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg3,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg3[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg3[chars_stored] = '\0';
+ }else {
+ arg3 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg3[i];i++){
+ printf("<0x%.4X>",arg3[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of Grammar_getElemId, Expected perl-string.");
+ XSRETURN(1);
+ }
}
- if (items > 3) {
- arg4 = (bool )SvIV(ST(3));
+ {
+ if (SvPOK(ST(3))||SvIOK(ST(3))||SvNOK(ST(3))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(3),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(3))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg4 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg4,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg4[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg4[chars_stored] = '\0';
+ }else {
+ arg4 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg4[i];i++){
+ printf("<0x%.4X>",arg4[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of Grammar_getElemId, Expected perl-string.");
+ XSRETURN(1);
+ }
}
+ arg5 = (unsigned int )SvIV(ST(4));
{
try {
- result = (bool )(arg1)->parseFirst((InputSource const &)*arg2,*arg3,arg4);
+ result = (unsigned int )((Grammar const *)arg1)->getElemId(arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,arg5);
}
catch (const XMLException& e)
@@ -62259,29 +64533,132 @@
}
}ST(argvi) = sv_newmortal();
sv_setiv(ST(argvi++),(IV) result);
+ {
+ delete[] arg3;
+ }
+ {
+ delete[] arg4;
+ }
XSRETURN(argvi);
}
-XS(_wrap_IDOMParser_parseNext) {
- IDOMParser *arg1 ;
- XMLPScanToken *arg2 ;
+XS(_wrap_Grammar_getElemDecl) {
+ Grammar *arg1 ;
+ unsigned int arg2 ;
+ XMLCh *arg3 ;
+ XMLCh *arg4 ;
+ unsigned int arg5 ;
int argvi = 0;
- bool result ;
+ XMLElementDecl *result ;
dXSARGS;
- if ((items < 2) || (items > 2))
- croak("Usage: IDOMParser_parseNext(self,token);");
- if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
- croak("Type error in argument 1 of IDOMParser_parseNext. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ if ((items < 5) || (items > 5))
+ croak("Usage: Grammar_getElemDecl(self,uriId,baseName,qName,scope);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_Grammar) < 0) {
+ croak("Type error in argument 1 of Grammar_getElemDecl. Expected %s", SWIGTYPE_p_Grammar->name);
XSRETURN(1);
}
- if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_XMLPScanToken) < 0) {
- croak("Type error in argument 2 of IDOMParser_parseNext. Expected %s", SWIGTYPE_p_XMLPScanToken->name);
- XSRETURN(1);
+ arg2 = (unsigned int )SvIV(ST(1));
+ {
+ if (SvPOK(ST(2))||SvIOK(ST(2))||SvNOK(ST(2))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(2),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(2))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg3 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg3,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg3[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg3[chars_stored] = '\0';
+ }else {
+ arg3 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg3[i];i++){
+ printf("<0x%.4X>",arg3[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of Grammar_getElemDecl, Expected perl-string.");
+ XSRETURN(1);
+ }
+ }
+ {
+ if (SvPOK(ST(3))||SvIOK(ST(3))||SvNOK(ST(3))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(3),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(3))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg4 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg4,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg4[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg4[chars_stored] = '\0';
+ }else {
+ arg4 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg4[i];i++){
+ printf("<0x%.4X>",arg4[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of Grammar_getElemDecl, Expected perl-string.");
+ XSRETURN(1);
+ }
}
+ arg5 = (unsigned int )SvIV(ST(4));
{
try {
- result = (bool )(arg1)->parseNext(*arg2);
+ result = (XMLElementDecl *)((Grammar const *)arg1)->getElemDecl(arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,arg5);
}
catch (const XMLException& e)
@@ -62306,29 +64683,80 @@
croak("%s", "Handling Unknown exception");
}
}ST(argvi) = sv_newmortal();
- sv_setiv(ST(argvi++),(IV) result);
+ SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_XMLElementDecl);
+ {
+ delete[] arg3;
+ }
+ {
+ delete[] arg4;
+ }
XSRETURN(argvi);
}
-XS(_wrap_IDOMParser_parseReset) {
- IDOMParser *arg1 ;
- XMLPScanToken *arg2 ;
+XS(_wrap_Grammar_getNotationDecl) {
+ Grammar *arg1 ;
+ XMLCh *arg2 ;
int argvi = 0;
+ XMLNotationDecl *result ;
dXSARGS;
if ((items < 2) || (items > 2))
- croak("Usage: IDOMParser_parseReset(self,token);");
- if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
- croak("Type error in argument 1 of IDOMParser_parseReset. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ croak("Usage: Grammar_getNotationDecl(self,notName);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_Grammar) < 0) {
+ croak("Type error in argument 1 of Grammar_getNotationDecl. Expected %s", SWIGTYPE_p_Grammar->name);
XSRETURN(1);
}
- if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_XMLPScanToken) < 0) {
- croak("Type error in argument 2 of IDOMParser_parseReset. Expected %s", SWIGTYPE_p_XMLPScanToken->name);
- XSRETURN(1);
+ {
+ if (SvPOK(ST(1))||SvIOK(ST(1))||SvNOK(ST(1))) {
+ STRLEN length;
+ char *ptr = (char *)SvPV(ST(1),length);
+ if (DEBUG_UTF8_IN) {
+ printf("Perl in length = %d: ",length);
+ for (unsigned int i=0;i<length;i++){
+ printf("<0x%.4X>",ptr[i]);
+ }
+ printf("\n");
+ }
+ if (SvUTF8(ST(1))) {
+ unsigned int charsEaten = 0;
+ unsigned char* sizes = new unsigned char[length+1];
+ arg2 = new XMLCh[length+1];
+ unsigned int chars_stored =
+ UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
+ (unsigned int) length,
+ (XMLCh*) arg2,
+ (unsigned int) length,
+ charsEaten,
+ (unsigned char*)sizes
+ );
+ delete [] sizes;
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces in length = %d: ",chars_stored);
+ for (unsigned int i=0;i<chars_stored;i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ // indicate the end of the string
+ arg2[chars_stored] = '\0';
+ }else {
+ arg2 = XMLString::transcode(ptr);
+ if (DEBUG_UTF8_IN) {
+ printf("Xerces: ");
+ for (int i=0;arg2[i];i++){
+ printf("<0x%.4X>",arg2[i]);
+ }
+ printf("\n");
+ }
+ }
+ }else {
+ croak("Type error in argument 2 of Grammar_getNotationDecl, Expected perl-string.");
+ XSRETURN(1);
+ }
}
{
try {
- (arg1)->parseReset(*arg2);
+ result = (XMLNotationDecl *)((Grammar const *)arg1)->getNotationDecl((XMLCh const *)arg2);
}
catch (const XMLException& e)
@@ -62352,26 +64780,29 @@
XMLPlatformUtils::Terminate();
croak("%s", "Handling Unknown exception");
}
- }XSRETURN(argvi);
+ }ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_XMLNotationDecl);
+ {
+ delete[] arg2;
+ }
+ XSRETURN(argvi);
}
-XS(_wrap_IDOMParser_error) {
- IDOMParser *arg1 ;
+XS(_wrap_Grammar_putElemDecl) {
+ Grammar *arg1 ;
unsigned int arg2 ;
XMLCh *arg3 ;
- XMLErrorReporter::ErrTypes *arg4 ;
+ XMLCh *arg4 ;
XMLCh *arg5 ;
- XMLCh *arg6 ;
- XMLCh *arg7 ;
- unsigned int arg8 ;
- unsigned int arg9 ;
+ unsigned int arg6 ;
int argvi = 0;
+ XMLElementDecl *result ;
dXSARGS;
- if ((items < 9) || (items > 9))
- croak("Usage: IDOMParser_error(self,errCode,msgDomain,errType,errorText,systemId,publicId,lineNum,colNum);");
- if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
- croak("Type error in argument 1 of IDOMParser_error. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ if ((items < 6) || (items > 6))
+ croak("Usage: Grammar_putElemDecl(self,uriId,baseName,prefixName,qName,scope);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_Grammar) < 0) {
+ croak("Type error in argument 1 of Grammar_putElemDecl. Expected %s", SWIGTYPE_p_Grammar->name);
XSRETURN(1);
}
arg2 = (unsigned int )SvIV(ST(1));
@@ -62419,66 +64850,14 @@
}
}
}else {
- croak("Type error in argument 2 of IDOMParser_error, Expected perl-string.");
- XSRETURN(1);
- }
- }
- if (SWIG_ConvertPtr(ST(3),(void **) &arg4,SWIGTYPE_p_XMLErrorReporter__ErrTypes) < 0) {
- croak("Type error in argument 4 of IDOMParser_error. Expected %s", SWIGTYPE_p_XMLErrorReporter__ErrTypes->name);
- XSRETURN(1);
- }
- {
- if (SvPOK(ST(4))||SvIOK(ST(4))||SvNOK(ST(4))) {
- STRLEN length;
- char *ptr = (char *)SvPV(ST(4),length);
- if (DEBUG_UTF8_IN) {
- printf("Perl in length = %d: ",length);
- for (unsigned int i=0;i<length;i++){
- printf("<0x%.4X>",ptr[i]);
- }
- printf("\n");
- }
- if (SvUTF8(ST(4))) {
- unsigned int charsEaten = 0;
- unsigned char* sizes = new unsigned char[length+1];
- arg5 = new XMLCh[length+1];
- unsigned int chars_stored =
- UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
- (unsigned int) length,
- (XMLCh*) arg5,
- (unsigned int) length,
- charsEaten,
- (unsigned char*)sizes
- );
- delete [] sizes;
- if (DEBUG_UTF8_IN) {
- printf("Xerces in length = %d: ",chars_stored);
- for (unsigned int i=0;i<chars_stored;i++){
- printf("<0x%.4X>",arg5[i]);
- }
- printf("\n");
- }
- // indicate the end of the string
- arg5[chars_stored] = '\0';
- }else {
- arg5 = XMLString::transcode(ptr);
- if (DEBUG_UTF8_IN) {
- printf("Xerces: ");
- for (int i=0;arg5[i];i++){
- printf("<0x%.4X>",arg5[i]);
- }
- printf("\n");
- }
- }
- }else {
- croak("Type error in argument 2 of IDOMParser_error, Expected perl-string.");
+ croak("Type error in argument 2 of Grammar_putElemDecl, Expected perl-string.");
XSRETURN(1);
}
}
{
- if (SvPOK(ST(5))||SvIOK(ST(5))||SvNOK(ST(5))) {
+ if (SvPOK(ST(3))||SvIOK(ST(3))||SvNOK(ST(3))) {
STRLEN length;
- char *ptr = (char *)SvPV(ST(5),length);
+ char *ptr = (char *)SvPV(ST(3),length);
if (DEBUG_UTF8_IN) {
printf("Perl in length = %d: ",length);
for (unsigned int i=0;i<length;i++){
@@ -62486,14 +64865,14 @@
}
printf("\n");
}
- if (SvUTF8(ST(5))) {
+ if (SvUTF8(ST(3))) {
unsigned int charsEaten = 0;
unsigned char* sizes = new unsigned char[length+1];
- arg6 = new XMLCh[length+1];
+ arg4 = new XMLCh[length+1];
unsigned int chars_stored =
UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
(unsigned int) length,
- (XMLCh*) arg6,
+ (XMLCh*) arg4,
(unsigned int) length,
charsEaten,
(unsigned char*)sizes
@@ -62502,31 +64881,31 @@
if (DEBUG_UTF8_IN) {
printf("Xerces in length = %d: ",chars_stored);
for (unsigned int i=0;i<chars_stored;i++){
- printf("<0x%.4X>",arg6[i]);
+ printf("<0x%.4X>",arg4[i]);
}
printf("\n");
}
// indicate the end of the string
- arg6[chars_stored] = '\0';
+ arg4[chars_stored] = '\0';
}else {
- arg6 = XMLString::transcode(ptr);
+ arg4 = XMLString::transcode(ptr);
if (DEBUG_UTF8_IN) {
printf("Xerces: ");
- for (int i=0;arg6[i];i++){
- printf("<0x%.4X>",arg6[i]);
+ for (int i=0;arg4[i];i++){
+ printf("<0x%.4X>",arg4[i]);
}
printf("\n");
}
}
}else {
- croak("Type error in argument 2 of IDOMParser_error, Expected perl-string.");
+ croak("Type error in argument 2 of Grammar_putElemDecl, Expected perl-string.");
XSRETURN(1);
}
}
{
- if (SvPOK(ST(6))||SvIOK(ST(6))||SvNOK(ST(6))) {
+ if (SvPOK(ST(4))||SvIOK(ST(4))||SvNOK(ST(4))) {
STRLEN length;
- char *ptr = (char *)SvPV(ST(6),length);
+ char *ptr = (char *)SvPV(ST(4),length);
if (DEBUG_UTF8_IN) {
printf("Perl in length = %d: ",length);
for (unsigned int i=0;i<length;i++){
@@ -62534,14 +64913,14 @@
}
printf("\n");
}
- if (SvUTF8(ST(6))) {
+ if (SvUTF8(ST(4))) {
unsigned int charsEaten = 0;
unsigned char* sizes = new unsigned char[length+1];
- arg7 = new XMLCh[length+1];
+ arg5 = new XMLCh[length+1];
unsigned int chars_stored =
UTF8_TRANSCODER->transcodeFrom((const XMLByte*) ptr,
(unsigned int) length,
- (XMLCh*) arg7,
+ (XMLCh*) arg5,
(unsigned int) length,
charsEaten,
(unsigned char*)sizes
@@ -62550,32 +64929,31 @@
if (DEBUG_UTF8_IN) {
printf("Xerces in length = %d: ",chars_stored);
for (unsigned int i=0;i<chars_stored;i++){
- printf("<0x%.4X>",arg7[i]);
+ printf("<0x%.4X>",arg5[i]);
}
printf("\n");
}
// indicate the end of the string
- arg7[chars_stored] = '\0';
+ arg5[chars_stored] = '\0';
}else {
- arg7 = XMLString::transcode(ptr);
+ arg5 = XMLString::transcode(ptr);
if (DEBUG_UTF8_IN) {
printf("Xerces: ");
- for (int i=0;arg7[i];i++){
- printf("<0x%.4X>",arg7[i]);
+ for (int i=0;arg5[i];i++){
+ printf("<0x%.4X>",arg5[i]);
}
printf("\n");
}
}
}else {
- croak("Type error in argument 2 of IDOMParser_error, Expected perl-string.");
+ croak("Type error in argument 2 of Grammar_putElemDecl, Expected perl-string.");
XSRETURN(1);
}
}
- arg8 = (unsigned int )SvIV(ST(7));
- arg9 = (unsigned int )SvIV(ST(8));
+ arg6 = (unsigned int )SvIV(ST(5));
{
try {
- (arg1)->error(arg2,(XMLCh const *)arg3,*arg4,(XMLCh const *)arg5,(XMLCh const *)arg6,(XMLCh const *)arg7,arg8,arg9);
+ result = (XMLElementDecl *)(arg1)->putElemDecl(arg2,(XMLCh const *)arg3,(XMLCh const *)arg4,(XMLCh const *)arg5,arg6);
}
catch (const XMLException& e)
@@ -62599,35 +64977,82 @@
XMLPlatformUtils::Terminate();
croak("%s", "Handling Unknown exception");
}
- }{
+ }ST(argvi) = sv_newmortal();
+ SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_XMLElementDecl);
+ {
delete[] arg3;
}
{
- delete[] arg5;
+ delete[] arg4;
}
{
- delete[] arg6;
+ delete[] arg5;
}
- {
- delete[] arg7;
+ XSRETURN(argvi);
+}
+
+XS(_wrap_Grammar_putNotationDecl) {
+ Grammar *arg1 ;
+ XMLNotationDecl *arg2 ;
+ int argvi = 0;
+ unsigned int result ;
+ dXSARGS;
+
+ if ((items < 2) || (items > 2))
+ croak("Usage: Grammar_putNotationDecl(self,notationDecl);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_Grammar) < 0) {
+ croak("Type error in argument 1 of Grammar_putNotationDecl. Expected %s", SWIGTYPE_p_Grammar->name);
+ XSRETURN(1);
}
+ if (SWIG_ConvertPtr(ST(1),(void **) &arg2,SWIGTYPE_p_XMLNotationDecl) < 0) {
+ croak("Type error in argument 2 of Grammar_putNotationDecl. Expected %s", SWIGTYPE_p_XMLNotationDecl->name);
+ XSRETURN(1);
+ }
+ {
+ try {
+ result = (unsigned int )((Grammar const *)arg1)->putNotationDecl(arg2);
+
+ }
+ catch (const XMLException& e)
+ {
+ char *class_name = "XML::Xerces::XMLException";
+ HV *hash = newHV();
+ HV *stash = gv_stashpv(class_name, FALSE);
+ SV *tmpsv;
+ hv_magic(hash,
+ (GV *)sv_setref_pv(sv_newmortal(),
+ class_name, (void *)&e),
+ 'P');
+ tmpsv = sv_bless(newRV_noinc((SV *)hash), stash);
+ SV *error = ERRSV;
+ SvSetSV(error,tmpsv);
+ (void)SvUPGRADE(error, SVt_PV);
+ Perl_die(Nullch);
+ }
+ catch (...)
+ {
+ XMLPlatformUtils::Terminate();
+ croak("%s", "Handling Unknown exception");
+ }
+ }ST(argvi) = sv_newmortal();
+ sv_setiv(ST(argvi++),(IV) result);
XSRETURN(argvi);
}
-XS(_wrap_IDOMParser_resetErrors) {
- IDOMParser *arg1 ;
+XS(_wrap_Grammar_reset) {
+ Grammar *arg1 ;
int argvi = 0;
dXSARGS;
if ((items < 1) || (items > 1))
- croak("Usage: IDOMParser_resetErrors(self);");
- if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_IDOMParser) < 0) {
- croak("Type error in argument 1 of IDOMParser_resetErrors. Expected %s", SWIGTYPE_p_IDOMParser->name);
+ croak("Usage: Grammar_reset(self);");
+ if (SWIG_ConvertPtr(ST(0),(void **) &arg1,SWIGTYPE_p_Grammar) < 0) {
+ croak("Type error in argument 1 of Grammar_reset. Expected %s", SWIGTYPE_p_Grammar->name);
XSRETURN(1);
}
{
try {
- (arg1)->resetErrors();
+ (arg1)->reset();
}
catch (const XMLException& e)
@@ -62828,8 +65253,8 @@
return (void *)((IDOM_CharacterData *) ((IDOM_CDATASection *) x));
}
static swig_type_info _swigt__p_IDOM_NodeIterator[] = {{"XML::Xerces::IDOM_NodeIterator", 0, "IDOM_NodeIterator *"},{"XML::Xerces::IDOM_NodeIterator"},{0}};
-static swig_type_info _swigt__p_DOM_Document[] = {{"XML::Xerces::DOM_Document", 0, "DOM_Document *"},{"XML::Xerces::DOM_Document"},{0}};
static swig_type_info _swigt__p_IDOM_Document[] = {{"XML::Xerces::IDOM_Document", 0, "IDOM_Document *"},{"XML::Xerces::IDOM_Document"},{0}};
+static swig_type_info _swigt__p_DOM_Document[] = {{"XML::Xerces::DOM_Document", 0, "DOM_Document *"},{"XML::Xerces::DOM_Document"},{0}};
static swig_type_info _swigt__p_DOM_NodeIterator[] = {{"XML::Xerces::DOM_NodeIterator", 0, "DOM_NodeIterator *"},{"XML::Xerces::DOM_NodeIterator"},{0}};
static swig_type_info _swigt__p_IDOM_DOMImplementation[] = {{"XML::Xerces::IDOM_DOMImplementation", 0, "IDOM_DOMImplementation *"},{"XML::Xerces::IDOM_DOMImplementation"},{0}};
static swig_type_info _swigt__p_DOM_DOMImplementation[] = {{"XML::Xerces::DOM_DOMImplementation", 0, "DOM_DOMImplementation *"},{"XML::Xerces::DOM_DOMImplementation"},{0}};
@@ -62839,10 +65264,12 @@
static swig_type_info _swigt__p_DOM_XMLDecl[] = {{"XML::Xerces::DOM_XMLDecl", 0, "DOM_XMLDecl *"},{"XML::Xerces::DOM_XMLDecl"},{0}};
static swig_type_info _swigt__p_XMLAttr[] = {{"_p_XMLAttr", 0, "XMLAttr *"},{"_p_XMLAttr"},{0}};
static swig_type_info _swigt__p_AttributeList[] = {{"XML::Xerces::AttributeList", 0, "AttributeList *"},{"XML::Xerces::AttributeList"},{0}};
+static swig_type_info _swigt__p_bool[] = {{"_p_bool", 0, "bool *"},{"_p_bool"},{0}};
static swig_type_info _swigt__p_IDOM_NodeFilter[] = {{"XML::Xerces::IDOM_NodeFilter", 0, "IDOM_NodeFilter *"},{"XML::Xerces::IDOM_NodeFilter"},{0}};
static swig_type_info _swigt__p_QName[] = {{"XML::Xerces::QName", 0, "QName *"},{"XML::Xerces::QName"},{0}};
static swig_type_info _swigt__p_p_QName[] = {{"_p_p_QName", 0, "QName **"},{"_p_p_QName"},{0}};
static swig_type_info _swigt__p_DOM_NodeFilter[] = {{"XML::Xerces::DOM_NodeFilter", 0, "DOM_NodeFilter *"},{"XML::Xerces::DOM_NodeFilter"},{0}};
+static swig_type_info _swigt__p_XMLNotationDecl[] = {{"_p_XMLNotationDecl", 0, "XMLNotationDecl *"},{"_p_XMLNotationDecl"},{0}};
static swig_type_info _swigt__p_IDOM_DocumentType[] = {{"XML::Xerces::IDOM_DocumentType", 0, "IDOM_DocumentType *"},{"XML::Xerces::IDOM_DocumentType"},{0}};
static swig_type_info _swigt__p_DOM_DocumentType[] = {{"XML::Xerces::DOM_DocumentType", 0, "DOM_DocumentType *"},{"XML::Xerces::DOM_DocumentType"},{0}};
static swig_type_info _swigt__p_XMLElementDecl[] = {{"XML::Xerces::XMLElementDecl", 0, "XMLElementDecl *"},{"XML::Xerces::XMLElementDecl"},{0}};
@@ -62934,8 +65361,8 @@
static swig_type_info *swig_types_initial[] = {
_swigt__p_IDOM_NodeIterator,
-_swigt__p_DOM_Document,
_swigt__p_IDOM_Document,
+_swigt__p_DOM_Document,
_swigt__p_DOM_NodeIterator,
_swigt__p_IDOM_DOMImplementation,
_swigt__p_DOM_DOMImplementation,
@@ -62945,10 +65372,12 @@
_swigt__p_DOM_XMLDecl,
_swigt__p_XMLAttr,
_swigt__p_AttributeList,
+_swigt__p_bool,
_swigt__p_IDOM_NodeFilter,
_swigt__p_QName,
_swigt__p_p_QName,
_swigt__p_DOM_NodeFilter,
+_swigt__p_XMLNotationDecl,
_swigt__p_IDOM_DocumentType,
_swigt__p_DOM_DocumentType,
_swigt__p_XMLElementDecl,
@@ -63065,7 +65494,10 @@
swig_setiv("XML::Xercesc::XMLURL_Protocols_Count", (long) XMLURL::Protocols_Count);
swig_setiv("XML::Xercesc::XMLURL_Unknown", (long) XMLURL::Unknown);
swig_setiv("XML::Xercesc::XMLExcepts_NoError", (long) XMLExcepts::NoError);
- swig_setiv("XML::Xercesc::XMLExcepts_E_LowBounds", (long) XMLExcepts::E_LowBounds);
+ swig_setiv("XML::Xercesc::XMLExcepts_W_LowBounds", (long) XMLExcepts::W_LowBounds);
+ swig_setiv("XML::Xercesc::XMLExcepts_Scan_CouldNotOpenSource_Warning", (long) XMLExcepts::Scan_CouldNotOpenSource_Warning);
+ swig_setiv("XML::Xercesc::XMLExcepts_W_HighBounds", (long) XMLExcepts::W_HighBounds);
+ swig_setiv("XML::Xercesc::XMLExcepts_F_LowBounds", (long) XMLExcepts::F_LowBounds);
swig_setiv("XML::Xercesc::XMLExcepts_Array_BadIndex", (long) XMLExcepts::Array_BadIndex);
swig_setiv("XML::Xercesc::XMLExcepts_Array_BadNewSize", (long) XMLExcepts::Array_BadNewSize);
swig_setiv("XML::Xercesc::XMLExcepts_AttrList_BadIndex", (long) XMLExcepts::AttrList_BadIndex);
@@ -63338,15 +65770,86 @@
swig_setiv("XML::Xercesc::XMLExcepts_Regex_RangeTokenGetError", (long) XMLExcepts::Regex_RangeTokenGetError);
swig_setiv("XML::Xercesc::XMLExcepts_Regex_NotSupported", (long) XMLExcepts::Regex_NotSupported);
swig_setiv("XML::Xercesc::XMLExcepts_Regex_InvalidChildIndex", (long) XMLExcepts::Regex_InvalidChildIndex);
+ swig_setiv("XML::Xercesc::XMLExcepts_Regex_InvalidQuantifier", (long) XMLExcepts::Regex_InvalidQuantifier);
swig_setiv("XML::Xercesc::XMLExcepts_NEL_RepeatedCalls", (long) XMLExcepts::NEL_RepeatedCalls);
swig_setiv("XML::Xercesc::XMLExcepts_RethrowError", (long) XMLExcepts::RethrowError);
swig_setiv("XML::Xercesc::XMLExcepts_Out_Of_Memory", (long) XMLExcepts::Out_Of_Memory);
swig_setiv("XML::Xercesc::XMLExcepts_DV_InvalidOperation", (long) XMLExcepts::DV_InvalidOperation);
- swig_setiv("XML::Xercesc::XMLExcepts_E_HighBounds", (long) XMLExcepts::E_HighBounds);
- swig_setiv("XML::Xercesc::XMLExcepts_W_LowBounds", (long) XMLExcepts::W_LowBounds);
- swig_setiv("XML::Xercesc::XMLExcepts_W_HighBounds", (long) XMLExcepts::W_HighBounds);
- swig_setiv("XML::Xercesc::XMLExcepts_F_LowBounds", (long) XMLExcepts::F_LowBounds);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_NoAttrSelector", (long) XMLExcepts::XPath_NoAttrSelector);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_NoUnionAtStart", (long) XMLExcepts::XPath_NoUnionAtStart);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_NoMultipleUnion", (long) XMLExcepts::XPath_NoMultipleUnion);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_MissingAttr", (long) XMLExcepts::XPath_MissingAttr);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_ExpectedToken1", (long) XMLExcepts::XPath_ExpectedToken1);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_PrefixNoURI", (long) XMLExcepts::XPath_PrefixNoURI);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_NoDoubleColon", (long) XMLExcepts::XPath_NoDoubleColon);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_ExpectedStep1", (long) XMLExcepts::XPath_ExpectedStep1);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_ExpectedStep2", (long) XMLExcepts::XPath_ExpectedStep2);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_ExpectedStep3", (long) XMLExcepts::XPath_ExpectedStep3);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_NoForwardSlash", (long) XMLExcepts::XPath_NoForwardSlash);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_NoDoubleForwardSlash", (long) XMLExcepts::XPath_NoDoubleForwardSlash);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_NoForwardSlashAtStart", (long) XMLExcepts::XPath_NoForwardSlashAtStart);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_NoSelectionOfRoot", (long) XMLExcepts::XPath_NoSelectionOfRoot);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_EmptyExpr", (long) XMLExcepts::XPath_EmptyExpr);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_NoUnionAtEnd", (long) XMLExcepts::XPath_NoUnionAtEnd);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_InvalidChar", (long) XMLExcepts::XPath_InvalidChar);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_TokenNotSupported", (long) XMLExcepts::XPath_TokenNotSupported);
+ swig_setiv("XML::Xercesc::XMLExcepts_XPath_FindSolution", (long) XMLExcepts::XPath_FindSolution);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_Assert_Buffer_Fail", (long) XMLExcepts::DateTime_Assert_Buffer_Fail);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_dt_missingT", (long) XMLExcepts::DateTime_dt_missingT);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_gDay_invalid", (long) XMLExcepts::DateTime_gDay_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_gMth_invalid", (long) XMLExcepts::DateTime_gMth_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_gMthDay_invalid", (long) XMLExcepts::DateTime_gMthDay_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_dur_Start_dashP", (long) XMLExcepts::DateTime_dur_Start_dashP);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_dur_noP", (long) XMLExcepts::DateTime_dur_noP);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_dur_DashNotFirst", (long) XMLExcepts::DateTime_dur_DashNotFirst);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_dur_inv_b4T", (long) XMLExcepts::DateTime_dur_inv_b4T);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_dur_NoTimeAfterT", (long) XMLExcepts::DateTime_dur_NoTimeAfterT);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_dur_NoElementAtAll", (long) XMLExcepts::DateTime_dur_NoElementAtAll);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_date_incomplete", (long) XMLExcepts::DateTime_date_incomplete);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_date_invalid", (long) XMLExcepts::DateTime_date_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_time_incomplete", (long) XMLExcepts::DateTime_time_incomplete);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_time_invalid", (long) XMLExcepts::DateTime_time_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_ms_noDigit", (long) XMLExcepts::DateTime_ms_noDigit);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_ym_incomplete", (long) XMLExcepts::DateTime_ym_incomplete);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_ym_invalid", (long) XMLExcepts::DateTime_ym_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_year_tooShort", (long) XMLExcepts::DateTime_year_tooShort);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_year_leadingZero", (long) XMLExcepts::DateTime_year_leadingZero);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_ym_noMonth", (long) XMLExcepts::DateTime_ym_noMonth);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_tz_noUTCsign", (long) XMLExcepts::DateTime_tz_noUTCsign);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_tz_stuffAfterZ", (long) XMLExcepts::DateTime_tz_stuffAfterZ);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_tz_invalid", (long) XMLExcepts::DateTime_tz_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_year_zero", (long) XMLExcepts::DateTime_year_zero);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_mth_invalid", (long) XMLExcepts::DateTime_mth_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_day_invalid", (long) XMLExcepts::DateTime_day_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_hour_invalid", (long) XMLExcepts::DateTime_hour_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_min_invalid", (long) XMLExcepts::DateTime_min_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_second_invalid", (long) XMLExcepts::DateTime_second_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_DateTime_tz_hh_invalid", (long) XMLExcepts::DateTime_tz_hh_invalid);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_NSCompat1", (long) XMLExcepts::PD_NSCompat1);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_OccurRangeE", (long) XMLExcepts::PD_OccurRangeE);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_NameTypeOK1", (long) XMLExcepts::PD_NameTypeOK1);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_NameTypeOK2", (long) XMLExcepts::PD_NameTypeOK2);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_NameTypeOK3", (long) XMLExcepts::PD_NameTypeOK3);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_NameTypeOK4", (long) XMLExcepts::PD_NameTypeOK4);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_NameTypeOK5", (long) XMLExcepts::PD_NameTypeOK5);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_NameTypeOK6", (long) XMLExcepts::PD_NameTypeOK6);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_NameTypeOK7", (long) XMLExcepts::PD_NameTypeOK7);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_RecurseAsIfGroup", (long) XMLExcepts::PD_RecurseAsIfGroup);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_Recurse1", (long) XMLExcepts::PD_Recurse1);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_Recurse2", (long) XMLExcepts::PD_Recurse2);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_ForbiddenRes1", (long) XMLExcepts::PD_ForbiddenRes1);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_ForbiddenRes2", (long) XMLExcepts::PD_ForbiddenRes2);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_ForbiddenRes3", (long) XMLExcepts::PD_ForbiddenRes3);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_ForbiddenRes4", (long) XMLExcepts::PD_ForbiddenRes4);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_NSSubset1", (long) XMLExcepts::PD_NSSubset1);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_NSSubset2", (long) XMLExcepts::PD_NSSubset2);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_NSRecurseCheckCardinality1", (long) XMLExcepts::PD_NSRecurseCheckCardinality1);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_RecurseUnordered", (long) XMLExcepts::PD_RecurseUnordered);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_MapAndSum", (long) XMLExcepts::PD_MapAndSum);
+ swig_setiv("XML::Xercesc::XMLExcepts_PD_InvalidContentType", (long) XMLExcepts::PD_InvalidContentType);
swig_setiv("XML::Xercesc::XMLExcepts_F_HighBounds", (long) XMLExcepts::F_HighBounds);
+ swig_setiv("XML::Xercesc::XMLExcepts_E_LowBounds", (long) XMLExcepts::E_LowBounds);
+ swig_setiv("XML::Xercesc::XMLExcepts_E_HighBounds", (long) XMLExcepts::E_HighBounds);
swig_setiv("XML::Xercesc::IDOM_Node_ELEMENT_NODE", (long) IDOM_Node::ELEMENT_NODE);
swig_setiv("XML::Xercesc::IDOM_Node_ATTRIBUTE_NODE", (long) IDOM_Node::ATTRIBUTE_NODE);
swig_setiv("XML::Xercesc::IDOM_Node_TEXT_NODE", (long) IDOM_Node::TEXT_NODE);
@@ -63459,6 +65962,10 @@
swig_setiv("XML::Xercesc::IDOMParser_Val_Never", (long) IDOMParser::Val_Never);
swig_setiv("XML::Xercesc::IDOMParser_Val_Always", (long) IDOMParser::Val_Always);
swig_setiv("XML::Xercesc::IDOMParser_Val_Auto", (long) IDOMParser::Val_Auto);
+ swig_setiv("XML::Xercesc::Grammar_DTDGrammarType", (long) Grammar::DTDGrammarType);
+ swig_setiv("XML::Xercesc::Grammar_SchemaGrammarType", (long) Grammar::SchemaGrammarType);
+ swig_setiv("XML::Xercesc::Grammar_UNKNOWN_SCOPE", (long) Grammar::UNKNOWN_SCOPE);
+ swig_setiv("XML::Xercesc::Grammar_TOP_LEVEL_SCOPE", (long) Grammar::TOP_LEVEL_SCOPE);
XSRETURN(1);
}
#ifdef __cplusplus
@@ -63573,6 +66080,8 @@
newXS((char *) "XML::Xercesc::QName_setName", _wrap_QName_setName, file);
newXS((char *) "XML::Xercesc::QName_setPrefix", _wrap_QName_setPrefix, file);
newXS((char *) "XML::Xercesc::QName_setLocalPart", _wrap_QName_setLocalPart, file);
+ newXS((char *) "XML::Xercesc::QName_setNPrefix", _wrap_QName_setNPrefix, file);
+ newXS((char *) "XML::Xercesc::QName_setNLocalPart", _wrap_QName_setNLocalPart, file);
newXS((char *) "XML::Xercesc::QName_setURI", _wrap_QName_setURI, file);
newXS((char *) "XML::Xercesc::QName_setValues", _wrap_QName_setValues, file);
newXS((char *) "XML::Xercesc::QName_operator_equal_to", _wrap_QName_operator_equal_to, file);
@@ -63588,11 +66097,13 @@
newXS((char *) "XML::Xercesc::XMLException_getMessage", _wrap_XMLException_getMessage, file);
newXS((char *) "XML::Xercesc::XMLException_getSrcFile", _wrap_XMLException_getSrcFile, file);
newXS((char *) "XML::Xercesc::XMLException_getSrcLine", _wrap_XMLException_getSrcLine, file);
+ newXS((char *) "XML::Xercesc::XMLException_getErrorType", _wrap_XMLException_getErrorType, file);
newXS((char *) "XML::Xercesc::XMLException_setPosition", _wrap_XMLException_setPosition, file);
newXS((char *) "XML::Xercesc::XMLException_operator_assignment", _wrap_XMLException_operator_assignment, file);
+ newXS((char *) "XML::Xercesc::XMLException_reinitMsgMutex", _wrap_XMLException_reinitMsgMutex, file);
+ newXS((char *) "XML::Xercesc::XMLException_reinitMsgLoader", _wrap_XMLException_reinitMsgLoader, file);
newXS((char *) "XML::Xercesc::delete_XMLValidator", _wrap_delete_XMLValidator, file);
newXS((char *) "XML::Xercesc::XMLValidator_checkContent", _wrap_XMLValidator_checkContent, file);
- newXS((char *) "XML::Xercesc::XMLValidator_checkRootElement", _wrap_XMLValidator_checkRootElement, file);
newXS((char *) "XML::Xercesc::XMLValidator_faultInAttr", _wrap_XMLValidator_faultInAttr, file);
newXS((char *) "XML::Xercesc::XMLValidator_preContentValidation", _wrap_XMLValidator_preContentValidation, file);
newXS((char *) "XML::Xercesc::XMLValidator_postParseValidation", _wrap_XMLValidator_postParseValidation, file);
@@ -63607,7 +66118,9 @@
newXS((char *) "XML::Xercesc::XMLValidator_setScannerInfo", _wrap_XMLValidator_setScannerInfo, file);
newXS((char *) "XML::Xercesc::XMLValidator_setErrorReporter", _wrap_XMLValidator_setErrorReporter, file);
newXS((char *) "XML::Xercesc::XMLValidator_emitError", _wrap_XMLValidator_emitError, file);
- newXS((char *) "XML::Xercesc::XMLValidator_reinitXMLValidator", _wrap_XMLValidator_reinitXMLValidator, file);
+ newXS((char *) "XML::Xercesc::XMLValidator_checkRootElement", _wrap_XMLValidator_checkRootElement, file);
+ newXS((char *) "XML::Xercesc::XMLValidator_reinitMsgMutex", _wrap_XMLValidator_reinitMsgMutex, file);
+ newXS((char *) "XML::Xercesc::XMLValidator_reinitMsgLoader", _wrap_XMLValidator_reinitMsgLoader, file);
newXS((char *) "XML::Xercesc::new_SAXException", _wrap_new_SAXException, file);
newXS((char *) "XML::Xercesc::delete_SAXException", _wrap_delete_SAXException, file);
newXS((char *) "XML::Xercesc::SAXException_operator_assignment", _wrap_SAXException_operator_assignment, file);
@@ -64189,9 +66702,11 @@
newXS((char *) "XML::Xercesc::InputSource_getEncoding", _wrap_InputSource_getEncoding, file);
newXS((char *) "XML::Xercesc::InputSource_getPublicId", _wrap_InputSource_getPublicId, file);
newXS((char *) "XML::Xercesc::InputSource_getSystemId", _wrap_InputSource_getSystemId, file);
+ newXS((char *) "XML::Xercesc::InputSource_getIssueFatalErrorIfNotFound", _wrap_InputSource_getIssueFatalErrorIfNotFound, file);
newXS((char *) "XML::Xercesc::InputSource_setEncoding", _wrap_InputSource_setEncoding, file);
newXS((char *) "XML::Xercesc::InputSource_setPublicId", _wrap_InputSource_setPublicId, file);
newXS((char *) "XML::Xercesc::InputSource_setSystemId", _wrap_InputSource_setSystemId, file);
+ newXS((char *) "XML::Xercesc::InputSource_setIssueFatalErrorIfNotFound", _wrap_InputSource_setIssueFatalErrorIfNotFound, file);
newXS((char *) "XML::Xercesc::new_MemBufInputSource", _wrap_new_MemBufInputSource, file);
newXS((char *) "XML::Xercesc::delete_MemBufInputSource", _wrap_delete_MemBufInputSource, file);
newXS((char *) "XML::Xercesc::MemBufInputSource_makeStream", _wrap_MemBufInputSource_makeStream, file);
@@ -64255,12 +66770,16 @@
newXS((char *) "XML::Xercesc::SAXParser_getDoNamespaces", _wrap_SAXParser_getDoNamespaces, file);
newXS((char *) "XML::Xercesc::SAXParser_getExitOnFirstFatalError", _wrap_SAXParser_getExitOnFirstFatalError, file);
newXS((char *) "XML::Xercesc::SAXParser_getValidationConstraintFatal", _wrap_SAXParser_getValidationConstraintFatal, file);
+ newXS((char *) "XML::Xercesc::SAXParser_getExternalSchemaLocation", _wrap_SAXParser_getExternalSchemaLocation, file);
+ newXS((char *) "XML::Xercesc::SAXParser_getExternalNoNamespaceSchemaLocation", _wrap_SAXParser_getExternalNoNamespaceSchemaLocation, file);
newXS((char *) "XML::Xercesc::SAXParser_setDoNamespaces", _wrap_SAXParser_setDoNamespaces, file);
newXS((char *) "XML::Xercesc::SAXParser_setValidationScheme", _wrap_SAXParser_setValidationScheme, file);
newXS((char *) "XML::Xercesc::SAXParser_setDoSchema", _wrap_SAXParser_setDoSchema, file);
newXS((char *) "XML::Xercesc::SAXParser_setValidationSchemaFullChecking", _wrap_SAXParser_setValidationSchemaFullChecking, file);
newXS((char *) "XML::Xercesc::SAXParser_setExitOnFirstFatalError", _wrap_SAXParser_setExitOnFirstFatalError, file);
newXS((char *) "XML::Xercesc::SAXParser_setValidationConstraintFatal", _wrap_SAXParser_setValidationConstraintFatal, file);
+ newXS((char *) "XML::Xercesc::SAXParser_setExternalSchemaLocation", _wrap_SAXParser_setExternalSchemaLocation, file);
+ newXS((char *) "XML::Xercesc::SAXParser_setExternalNoNamespaceSchemaLocation", _wrap_SAXParser_setExternalNoNamespaceSchemaLocation, file);
newXS((char *) "XML::Xercesc::SAXParser_installAdvDocHandler", _wrap_SAXParser_installAdvDocHandler, file);
newXS((char *) "XML::Xercesc::SAXParser_removeAdvDocHandler", _wrap_SAXParser_removeAdvDocHandler, file);
newXS((char *) "XML::Xercesc::SAXParser_parse__overload__is", _wrap_SAXParser_parse__overload__is, file);
@@ -64290,22 +66809,24 @@
newXS((char *) "XML::Xercesc::DOMParser_getDoNamespaces", _wrap_DOMParser_getDoNamespaces, file);
newXS((char *) "XML::Xercesc::DOMParser_getExitOnFirstFatalError", _wrap_DOMParser_getExitOnFirstFatalError, file);
newXS((char *) "XML::Xercesc::DOMParser_getValidationConstraintFatal", _wrap_DOMParser_getValidationConstraintFatal, file);
- newXS((char *) "XML::Xercesc::DOMParser_getExpandEntityReferences", _wrap_DOMParser_getExpandEntityReferences, file);
newXS((char *) "XML::Xercesc::DOMParser_getCreateEntityReferenceNodes", _wrap_DOMParser_getCreateEntityReferenceNodes, file);
newXS((char *) "XML::Xercesc::DOMParser_getIncludeIgnorableWhitespace", _wrap_DOMParser_getIncludeIgnorableWhitespace, file);
newXS((char *) "XML::Xercesc::DOMParser_getToCreateXMLDeclTypeNode", _wrap_DOMParser_getToCreateXMLDeclTypeNode, file);
+ newXS((char *) "XML::Xercesc::DOMParser_getExternalSchemaLocation", _wrap_DOMParser_getExternalSchemaLocation, file);
+ newXS((char *) "XML::Xercesc::DOMParser_getExternalNoNamespaceSchemaLocation", _wrap_DOMParser_getExternalNoNamespaceSchemaLocation, file);
newXS((char *) "XML::Xercesc::DOMParser_setErrorHandler", _wrap_DOMParser_setErrorHandler, file);
newXS((char *) "XML::Xercesc::DOMParser_setEntityResolver", _wrap_DOMParser_setEntityResolver, file);
newXS((char *) "XML::Xercesc::DOMParser_setDoNamespaces", _wrap_DOMParser_setDoNamespaces, file);
newXS((char *) "XML::Xercesc::DOMParser_setExitOnFirstFatalError", _wrap_DOMParser_setExitOnFirstFatalError, file);
newXS((char *) "XML::Xercesc::DOMParser_setValidationConstraintFatal", _wrap_DOMParser_setValidationConstraintFatal, file);
- newXS((char *) "XML::Xercesc::DOMParser_setExpandEntityReferences", _wrap_DOMParser_setExpandEntityReferences, file);
newXS((char *) "XML::Xercesc::DOMParser_setCreateEntityReferenceNodes", _wrap_DOMParser_setCreateEntityReferenceNodes, file);
newXS((char *) "XML::Xercesc::DOMParser_setIncludeIgnorableWhitespace", _wrap_DOMParser_setIncludeIgnorableWhitespace, file);
newXS((char *) "XML::Xercesc::DOMParser_setValidationScheme", _wrap_DOMParser_setValidationScheme, file);
newXS((char *) "XML::Xercesc::DOMParser_setDoSchema", _wrap_DOMParser_setDoSchema, file);
newXS((char *) "XML::Xercesc::DOMParser_setValidationSchemaFullChecking", _wrap_DOMParser_setValidationSchemaFullChecking, file);
newXS((char *) "XML::Xercesc::DOMParser_setToCreateXMLDeclTypeNode", _wrap_DOMParser_setToCreateXMLDeclTypeNode, file);
+ newXS((char *) "XML::Xercesc::DOMParser_setExternalSchemaLocation", _wrap_DOMParser_setExternalSchemaLocation, file);
+ newXS((char *) "XML::Xercesc::DOMParser_setExternalNoNamespaceSchemaLocation", _wrap_DOMParser_setExternalNoNamespaceSchemaLocation, file);
newXS((char *) "XML::Xercesc::DOMParser_parse__overload__is", _wrap_DOMParser_parse__overload__is, file);
newXS((char *) "XML::Xercesc::DOMParser_parse", _wrap_DOMParser_parse, file);
newXS((char *) "XML::Xercesc::DOMParser_parseFirst", _wrap_DOMParser_parseFirst, file);
@@ -64314,6 +66835,8 @@
newXS((char *) "XML::Xercesc::DOMParser_parseReset", _wrap_DOMParser_parseReset, file);
newXS((char *) "XML::Xercesc::DOMParser_error", _wrap_DOMParser_error, file);
newXS((char *) "XML::Xercesc::DOMParser_resetErrors", _wrap_DOMParser_resetErrors, file);
+ newXS((char *) "XML::Xercesc::DOMParser_setExpandEntityReferences", _wrap_DOMParser_setExpandEntityReferences, file);
+ newXS((char *) "XML::Xercesc::DOMParser_getExpandEntityReferences", _wrap_DOMParser_getExpandEntityReferences, file);
newXS((char *) "XML::Xercesc::new_IDOMParser", _wrap_new_IDOMParser, file);
newXS((char *) "XML::Xercesc::delete_IDOMParser", _wrap_delete_IDOMParser, file);
newXS((char *) "XML::Xercesc::IDOMParser_reset", _wrap_IDOMParser_reset, file);
@@ -64332,6 +66855,8 @@
newXS((char *) "XML::Xercesc::IDOMParser_getExpandEntityReferences", _wrap_IDOMParser_getExpandEntityReferences, file);
newXS((char *) "XML::Xercesc::IDOMParser_getCreateEntityReferenceNodes", _wrap_IDOMParser_getCreateEntityReferenceNodes, file);
newXS((char *) "XML::Xercesc::IDOMParser_getIncludeIgnorableWhitespace", _wrap_IDOMParser_getIncludeIgnorableWhitespace, file);
+ newXS((char *) "XML::Xercesc::IDOMParser_getExternalSchemaLocation", _wrap_IDOMParser_getExternalSchemaLocation, file);
+ newXS((char *) "XML::Xercesc::IDOMParser_getExternalNoNamespaceSchemaLocation", _wrap_IDOMParser_getExternalNoNamespaceSchemaLocation, file);
newXS((char *) "XML::Xercesc::IDOMParser_setErrorHandler", _wrap_IDOMParser_setErrorHandler, file);
newXS((char *) "XML::Xercesc::IDOMParser_setEntityResolver", _wrap_IDOMParser_setEntityResolver, file);
newXS((char *) "XML::Xercesc::IDOMParser_setDoNamespaces", _wrap_IDOMParser_setDoNamespaces, file);
@@ -64343,6 +66868,8 @@
newXS((char *) "XML::Xercesc::IDOMParser_setValidationScheme", _wrap_IDOMParser_setValidationScheme, file);
newXS((char *) "XML::Xercesc::IDOMParser_setDoSchema", _wrap_IDOMParser_setDoSchema, file);
newXS((char *) "XML::Xercesc::IDOMParser_setValidationSchemaFullChecking", _wrap_IDOMParser_setValidationSchemaFullChecking, file);
+ newXS((char *) "XML::Xercesc::IDOMParser_setExternalSchemaLocation", _wrap_IDOMParser_setExternalSchemaLocation, file);
+ newXS((char *) "XML::Xercesc::IDOMParser_setExternalNoNamespaceSchemaLocation", _wrap_IDOMParser_setExternalNoNamespaceSchemaLocation, file);
newXS((char *) "XML::Xercesc::IDOMParser_parse__overload__is", _wrap_IDOMParser_parse__overload__is, file);
newXS((char *) "XML::Xercesc::IDOMParser_parse", _wrap_IDOMParser_parse, file);
newXS((char *) "XML::Xercesc::IDOMParser_parseFirst", _wrap_IDOMParser_parseFirst, file);
@@ -64351,6 +66878,16 @@
newXS((char *) "XML::Xercesc::IDOMParser_parseReset", _wrap_IDOMParser_parseReset, file);
newXS((char *) "XML::Xercesc::IDOMParser_error", _wrap_IDOMParser_error, file);
newXS((char *) "XML::Xercesc::IDOMParser_resetErrors", _wrap_IDOMParser_resetErrors, file);
+ newXS((char *) "XML::Xercesc::delete_Grammar", _wrap_delete_Grammar, file);
+ newXS((char *) "XML::Xercesc::Grammar_getGrammarType", _wrap_Grammar_getGrammarType, file);
+ newXS((char *) "XML::Xercesc::Grammar_getTargetNamespace", _wrap_Grammar_getTargetNamespace, file);
+ newXS((char *) "XML::Xercesc::Grammar_findOrAddElemDecl", _wrap_Grammar_findOrAddElemDecl, file);
+ newXS((char *) "XML::Xercesc::Grammar_getElemId", _wrap_Grammar_getElemId, file);
+ newXS((char *) "XML::Xercesc::Grammar_getElemDecl", _wrap_Grammar_getElemDecl, file);
+ newXS((char *) "XML::Xercesc::Grammar_getNotationDecl", _wrap_Grammar_getNotationDecl, file);
+ newXS((char *) "XML::Xercesc::Grammar_putElemDecl", _wrap_Grammar_putElemDecl, file);
+ newXS((char *) "XML::Xercesc::Grammar_putNotationDecl", _wrap_Grammar_putNotationDecl, file);
+ newXS((char *) "XML::Xercesc::Grammar_reset", _wrap_Grammar_reset, file);
ST(0) = &PL_sv_yes;
XSRETURN(1);
}
1.14 +5 -1 xml-xerces/perl/Xerces.i
Index: Xerces.i
===================================================================
RCS file: /home/cvs/xml-xerces/perl/Xerces.i,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -r1.13 -r1.14
--- Xerces.i 3 Nov 2001 05:09:15 -0000 1.13
+++ Xerces.i 21 Feb 2002 03:10:26 -0000 1.14
@@ -32,12 +32,13 @@
#include "framework/StdInInputSource.hpp"
#include "framework/URLInputSource.hpp"
#include "framework/XMLValidator.hpp"
+#include "validators/common/Grammar.hpp"
+
#include "PerlErrorCallbackHandler.hpp"
#include "PerlEntityResolverHandler.i"
#include "PerlDocumentCallbackHandler.hpp"
#include "PerlContentCallbackHandler.hpp"
-
// we initialize the static UTF-8 transcoding info
// these are used by the typemaps to convert between
// Xerces internal UTF-16 and Perl's internal UTF-8
@@ -502,6 +503,9 @@
%include "parsers/DOMParser.hpp"
%include "parsers/IDOMParser.hpp"
+%include "validators/common/Grammar.hpp"
+
/* %pragma(perl5) include="Xerces-extra.pm" */
%pragma(perl5) code="package XML::Xerces;
$VERSION = q[1.5.2_0];";
+
1.5 +157 -9 xml-xerces/perl/Xerces.pm
Index: Xerces.pm
===================================================================
RCS file: /home/cvs/xml-xerces/perl/Xerces.pm,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- Xerces.pm 3 Nov 2001 05:11:05 -0000 1.4
+++ Xerces.pm 21 Feb 2002 03:10:26 -0000 1.5
@@ -291,6 +291,8 @@
*setName = *XML::Xercesc::QName_setName;
*setPrefix = *XML::Xercesc::QName_setPrefix;
*setLocalPart = *XML::Xercesc::QName_setLocalPart;
+*setNPrefix = *XML::Xercesc::QName_setNPrefix;
+*setNLocalPart = *XML::Xercesc::QName_setNLocalPart;
*setURI = *XML::Xercesc::QName_setURI;
*setValues = *XML::Xercesc::QName_setValues;
*operator_equal_to = *XML::Xercesc::QName_operator_equal_to;
@@ -355,7 +357,10 @@
@ISA = qw( XML::Xerces );
%OWNER = ();
*NoError = *XML::Xercesc::XMLExcepts_NoError;
-*E_LowBounds = *XML::Xercesc::XMLExcepts_E_LowBounds;
+*W_LowBounds = *XML::Xercesc::XMLExcepts_W_LowBounds;
+*Scan_CouldNotOpenSource_Warning = *XML::Xercesc::XMLExcepts_Scan_CouldNotOpenSource_Warning;
+*W_HighBounds = *XML::Xercesc::XMLExcepts_W_HighBounds;
+*F_LowBounds = *XML::Xercesc::XMLExcepts_F_LowBounds;
*Array_BadIndex = *XML::Xercesc::XMLExcepts_Array_BadIndex;
*Array_BadNewSize = *XML::Xercesc::XMLExcepts_Array_BadNewSize;
*AttrList_BadIndex = *XML::Xercesc::XMLExcepts_AttrList_BadIndex;
@@ -628,15 +633,86 @@
*Regex_RangeTokenGetError = *XML::Xercesc::XMLExcepts_Regex_RangeTokenGetError;
*Regex_NotSupported = *XML::Xercesc::XMLExcepts_Regex_NotSupported;
*Regex_InvalidChildIndex = *XML::Xercesc::XMLExcepts_Regex_InvalidChildIndex;
+*Regex_InvalidQuantifier = *XML::Xercesc::XMLExcepts_Regex_InvalidQuantifier;
*NEL_RepeatedCalls = *XML::Xercesc::XMLExcepts_NEL_RepeatedCalls;
*RethrowError = *XML::Xercesc::XMLExcepts_RethrowError;
*Out_Of_Memory = *XML::Xercesc::XMLExcepts_Out_Of_Memory;
*DV_InvalidOperation = *XML::Xercesc::XMLExcepts_DV_InvalidOperation;
-*E_HighBounds = *XML::Xercesc::XMLExcepts_E_HighBounds;
-*W_LowBounds = *XML::Xercesc::XMLExcepts_W_LowBounds;
-*W_HighBounds = *XML::Xercesc::XMLExcepts_W_HighBounds;
-*F_LowBounds = *XML::Xercesc::XMLExcepts_F_LowBounds;
+*XPath_NoAttrSelector = *XML::Xercesc::XMLExcepts_XPath_NoAttrSelector;
+*XPath_NoUnionAtStart = *XML::Xercesc::XMLExcepts_XPath_NoUnionAtStart;
+*XPath_NoMultipleUnion = *XML::Xercesc::XMLExcepts_XPath_NoMultipleUnion;
+*XPath_MissingAttr = *XML::Xercesc::XMLExcepts_XPath_MissingAttr;
+*XPath_ExpectedToken1 = *XML::Xercesc::XMLExcepts_XPath_ExpectedToken1;
+*XPath_PrefixNoURI = *XML::Xercesc::XMLExcepts_XPath_PrefixNoURI;
+*XPath_NoDoubleColon = *XML::Xercesc::XMLExcepts_XPath_NoDoubleColon;
+*XPath_ExpectedStep1 = *XML::Xercesc::XMLExcepts_XPath_ExpectedStep1;
+*XPath_ExpectedStep2 = *XML::Xercesc::XMLExcepts_XPath_ExpectedStep2;
+*XPath_ExpectedStep3 = *XML::Xercesc::XMLExcepts_XPath_ExpectedStep3;
+*XPath_NoForwardSlash = *XML::Xercesc::XMLExcepts_XPath_NoForwardSlash;
+*XPath_NoDoubleForwardSlash = *XML::Xercesc::XMLExcepts_XPath_NoDoubleForwardSlash;
+*XPath_NoForwardSlashAtStart = *XML::Xercesc::XMLExcepts_XPath_NoForwardSlashAtStart;
+*XPath_NoSelectionOfRoot = *XML::Xercesc::XMLExcepts_XPath_NoSelectionOfRoot;
+*XPath_EmptyExpr = *XML::Xercesc::XMLExcepts_XPath_EmptyExpr;
+*XPath_NoUnionAtEnd = *XML::Xercesc::XMLExcepts_XPath_NoUnionAtEnd;
+*XPath_InvalidChar = *XML::Xercesc::XMLExcepts_XPath_InvalidChar;
+*XPath_TokenNotSupported = *XML::Xercesc::XMLExcepts_XPath_TokenNotSupported;
+*XPath_FindSolution = *XML::Xercesc::XMLExcepts_XPath_FindSolution;
+*DateTime_Assert_Buffer_Fail = *XML::Xercesc::XMLExcepts_DateTime_Assert_Buffer_Fail;
+*DateTime_dt_missingT = *XML::Xercesc::XMLExcepts_DateTime_dt_missingT;
+*DateTime_gDay_invalid = *XML::Xercesc::XMLExcepts_DateTime_gDay_invalid;
+*DateTime_gMth_invalid = *XML::Xercesc::XMLExcepts_DateTime_gMth_invalid;
+*DateTime_gMthDay_invalid = *XML::Xercesc::XMLExcepts_DateTime_gMthDay_invalid;
+*DateTime_dur_Start_dashP = *XML::Xercesc::XMLExcepts_DateTime_dur_Start_dashP;
+*DateTime_dur_noP = *XML::Xercesc::XMLExcepts_DateTime_dur_noP;
+*DateTime_dur_DashNotFirst = *XML::Xercesc::XMLExcepts_DateTime_dur_DashNotFirst;
+*DateTime_dur_inv_b4T = *XML::Xercesc::XMLExcepts_DateTime_dur_inv_b4T;
+*DateTime_dur_NoTimeAfterT = *XML::Xercesc::XMLExcepts_DateTime_dur_NoTimeAfterT;
+*DateTime_dur_NoElementAtAll = *XML::Xercesc::XMLExcepts_DateTime_dur_NoElementAtAll;
+*DateTime_date_incomplete = *XML::Xercesc::XMLExcepts_DateTime_date_incomplete;
+*DateTime_date_invalid = *XML::Xercesc::XMLExcepts_DateTime_date_invalid;
+*DateTime_time_incomplete = *XML::Xercesc::XMLExcepts_DateTime_time_incomplete;
+*DateTime_time_invalid = *XML::Xercesc::XMLExcepts_DateTime_time_invalid;
+*DateTime_ms_noDigit = *XML::Xercesc::XMLExcepts_DateTime_ms_noDigit;
+*DateTime_ym_incomplete = *XML::Xercesc::XMLExcepts_DateTime_ym_incomplete;
+*DateTime_ym_invalid = *XML::Xercesc::XMLExcepts_DateTime_ym_invalid;
+*DateTime_year_tooShort = *XML::Xercesc::XMLExcepts_DateTime_year_tooShort;
+*DateTime_year_leadingZero = *XML::Xercesc::XMLExcepts_DateTime_year_leadingZero;
+*DateTime_ym_noMonth = *XML::Xercesc::XMLExcepts_DateTime_ym_noMonth;
+*DateTime_tz_noUTCsign = *XML::Xercesc::XMLExcepts_DateTime_tz_noUTCsign;
+*DateTime_tz_stuffAfterZ = *XML::Xercesc::XMLExcepts_DateTime_tz_stuffAfterZ;
+*DateTime_tz_invalid = *XML::Xercesc::XMLExcepts_DateTime_tz_invalid;
+*DateTime_year_zero = *XML::Xercesc::XMLExcepts_DateTime_year_zero;
+*DateTime_mth_invalid = *XML::Xercesc::XMLExcepts_DateTime_mth_invalid;
+*DateTime_day_invalid = *XML::Xercesc::XMLExcepts_DateTime_day_invalid;
+*DateTime_hour_invalid = *XML::Xercesc::XMLExcepts_DateTime_hour_invalid;
+*DateTime_min_invalid = *XML::Xercesc::XMLExcepts_DateTime_min_invalid;
+*DateTime_second_invalid = *XML::Xercesc::XMLExcepts_DateTime_second_invalid;
+*DateTime_tz_hh_invalid = *XML::Xercesc::XMLExcepts_DateTime_tz_hh_invalid;
+*PD_NSCompat1 = *XML::Xercesc::XMLExcepts_PD_NSCompat1;
+*PD_OccurRangeE = *XML::Xercesc::XMLExcepts_PD_OccurRangeE;
+*PD_NameTypeOK1 = *XML::Xercesc::XMLExcepts_PD_NameTypeOK1;
+*PD_NameTypeOK2 = *XML::Xercesc::XMLExcepts_PD_NameTypeOK2;
+*PD_NameTypeOK3 = *XML::Xercesc::XMLExcepts_PD_NameTypeOK3;
+*PD_NameTypeOK4 = *XML::Xercesc::XMLExcepts_PD_NameTypeOK4;
+*PD_NameTypeOK5 = *XML::Xercesc::XMLExcepts_PD_NameTypeOK5;
+*PD_NameTypeOK6 = *XML::Xercesc::XMLExcepts_PD_NameTypeOK6;
+*PD_NameTypeOK7 = *XML::Xercesc::XMLExcepts_PD_NameTypeOK7;
+*PD_RecurseAsIfGroup = *XML::Xercesc::XMLExcepts_PD_RecurseAsIfGroup;
+*PD_Recurse1 = *XML::Xercesc::XMLExcepts_PD_Recurse1;
+*PD_Recurse2 = *XML::Xercesc::XMLExcepts_PD_Recurse2;
+*PD_ForbiddenRes1 = *XML::Xercesc::XMLExcepts_PD_ForbiddenRes1;
+*PD_ForbiddenRes2 = *XML::Xercesc::XMLExcepts_PD_ForbiddenRes2;
+*PD_ForbiddenRes3 = *XML::Xercesc::XMLExcepts_PD_ForbiddenRes3;
+*PD_ForbiddenRes4 = *XML::Xercesc::XMLExcepts_PD_ForbiddenRes4;
+*PD_NSSubset1 = *XML::Xercesc::XMLExcepts_PD_NSSubset1;
+*PD_NSSubset2 = *XML::Xercesc::XMLExcepts_PD_NSSubset2;
+*PD_NSRecurseCheckCardinality1 = *XML::Xercesc::XMLExcepts_PD_NSRecurseCheckCardinality1;
+*PD_RecurseUnordered = *XML::Xercesc::XMLExcepts_PD_RecurseUnordered;
+*PD_MapAndSum = *XML::Xercesc::XMLExcepts_PD_MapAndSum;
+*PD_InvalidContentType = *XML::Xercesc::XMLExcepts_PD_InvalidContentType;
*F_HighBounds = *XML::Xercesc::XMLExcepts_F_HighBounds;
+*E_LowBounds = *XML::Xercesc::XMLExcepts_E_LowBounds;
+*E_HighBounds = *XML::Xercesc::XMLExcepts_E_HighBounds;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -665,8 +741,11 @@
*getMessage = *XML::Xercesc::XMLException_getMessage;
*getSrcFile = *XML::Xercesc::XMLException_getSrcFile;
*getSrcLine = *XML::Xercesc::XMLException_getSrcLine;
+*getErrorType = *XML::Xercesc::XMLException_getErrorType;
*setPosition = *XML::Xercesc::XMLException_setPosition;
*operator_assignment = *XML::Xercesc::XMLException_operator_assignment;
+*reinitMsgMutex = *XML::Xercesc::XMLException_reinitMsgMutex;
+*reinitMsgLoader = *XML::Xercesc::XMLException_reinitMsgLoader;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -688,7 +767,6 @@
%ITERATORS = ();
*checkContent = *XML::Xercesc::XMLValidator_checkContent;
-*checkRootElement = *XML::Xercesc::XMLValidator_checkRootElement;
*faultInAttr = *XML::Xercesc::XMLValidator_faultInAttr;
*preContentValidation = *XML::Xercesc::XMLValidator_preContentValidation;
*postParseValidation = *XML::Xercesc::XMLValidator_postParseValidation;
@@ -710,7 +788,9 @@
*setScannerInfo = *XML::Xercesc::XMLValidator_setScannerInfo;
*setErrorReporter = *XML::Xercesc::XMLValidator_setErrorReporter;
*emitError = *XML::Xercesc::XMLValidator_emitError;
-*reinitXMLValidator = *XML::Xercesc::XMLValidator_reinitXMLValidator;
+*checkRootElement = *XML::Xercesc::XMLValidator_checkRootElement;
+*reinitMsgMutex = *XML::Xercesc::XMLValidator_reinitMsgMutex;
+*reinitMsgLoader = *XML::Xercesc::XMLValidator_reinitMsgLoader;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -4983,9 +5063,11 @@
*getEncoding = *XML::Xercesc::InputSource_getEncoding;
*getPublicId = *XML::Xercesc::InputSource_getPublicId;
*getSystemId = *XML::Xercesc::InputSource_getSystemId;
+*getIssueFatalErrorIfNotFound = *XML::Xercesc::InputSource_getIssueFatalErrorIfNotFound;
*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);
@@ -5434,12 +5516,16 @@
*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;
*setDoNamespaces = *XML::Xercesc::SAXParser_setDoNamespaces;
*setValidationScheme = *XML::Xercesc::SAXParser_setValidationScheme;
*setDoSchema = *XML::Xercesc::SAXParser_setDoSchema;
*setValidationSchemaFullChecking = *XML::Xercesc::SAXParser_setValidationSchemaFullChecking;
*setExitOnFirstFatalError = *XML::Xercesc::SAXParser_setExitOnFirstFatalError;
*setValidationConstraintFatal = *XML::Xercesc::SAXParser_setValidationConstraintFatal;
+*setExternalSchemaLocation = *XML::Xercesc::SAXParser_setExternalSchemaLocation;
+*setExternalNoNamespaceSchemaLocation = *XML::Xercesc::SAXParser_setExternalNoNamespaceSchemaLocation;
*installAdvDocHandler = *XML::Xercesc::SAXParser_installAdvDocHandler;
*removeAdvDocHandler = *XML::Xercesc::SAXParser_removeAdvDocHandler;
sub parse {
@@ -5581,10 +5667,11 @@
*getDoNamespaces = *XML::Xercesc::DOMParser_getDoNamespaces;
*getExitOnFirstFatalError = *XML::Xercesc::DOMParser_getExitOnFirstFatalError;
*getValidationConstraintFatal = *XML::Xercesc::DOMParser_getValidationConstraintFatal;
-*getExpandEntityReferences = *XML::Xercesc::DOMParser_getExpandEntityReferences;
*getCreateEntityReferenceNodes = *XML::Xercesc::DOMParser_getCreateEntityReferenceNodes;
*getIncludeIgnorableWhitespace = *XML::Xercesc::DOMParser_getIncludeIgnorableWhitespace;
*getToCreateXMLDeclTypeNode = *XML::Xercesc::DOMParser_getToCreateXMLDeclTypeNode;
+*getExternalSchemaLocation = *XML::Xercesc::DOMParser_getExternalSchemaLocation;
+*getExternalNoNamespaceSchemaLocation = *XML::Xercesc::DOMParser_getExternalNoNamespaceSchemaLocation;
sub setErrorHandler {
my ($self,$handler) = @_;
my $callback = XML::Xerces::PerlErrorCallbackHandler->new();
@@ -5602,13 +5689,14 @@
*setDoNamespaces = *XML::Xercesc::DOMParser_setDoNamespaces;
*setExitOnFirstFatalError = *XML::Xercesc::DOMParser_setExitOnFirstFatalError;
*setValidationConstraintFatal = *XML::Xercesc::DOMParser_setValidationConstraintFatal;
-*setExpandEntityReferences = *XML::Xercesc::DOMParser_setExpandEntityReferences;
*setCreateEntityReferenceNodes = *XML::Xercesc::DOMParser_setCreateEntityReferenceNodes;
*setIncludeIgnorableWhitespace = *XML::Xercesc::DOMParser_setIncludeIgnorableWhitespace;
*setValidationScheme = *XML::Xercesc::DOMParser_setValidationScheme;
*setDoSchema = *XML::Xercesc::DOMParser_setDoSchema;
*setValidationSchemaFullChecking = *XML::Xercesc::DOMParser_setValidationSchemaFullChecking;
*setToCreateXMLDeclTypeNode = *XML::Xercesc::DOMParser_setToCreateXMLDeclTypeNode;
+*setExternalSchemaLocation = *XML::Xercesc::DOMParser_setExternalSchemaLocation;
+*setExternalNoNamespaceSchemaLocation = *XML::Xercesc::DOMParser_setExternalNoNamespaceSchemaLocation;
sub parse {
my @args = @_;
if (ref $args[1]) {
@@ -5629,6 +5717,8 @@
*parseReset = *XML::Xercesc::DOMParser_parseReset;
*error = *XML::Xercesc::DOMParser_error;
*resetErrors = *XML::Xercesc::DOMParser_resetErrors;
+*setExpandEntityReferences = *XML::Xercesc::DOMParser_setExpandEntityReferences;
+*getExpandEntityReferences = *XML::Xercesc::DOMParser_getExpandEntityReferences;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
@@ -5721,6 +5811,8 @@
*getExpandEntityReferences = *XML::Xercesc::IDOMParser_getExpandEntityReferences;
*getCreateEntityReferenceNodes = *XML::Xercesc::IDOMParser_getCreateEntityReferenceNodes;
*getIncludeIgnorableWhitespace = *XML::Xercesc::IDOMParser_getIncludeIgnorableWhitespace;
+*getExternalSchemaLocation = *XML::Xercesc::IDOMParser_getExternalSchemaLocation;
+*getExternalNoNamespaceSchemaLocation = *XML::Xercesc::IDOMParser_getExternalNoNamespaceSchemaLocation;
sub setErrorHandler {
my ($self,$handler) = @_;
my $callback = XML::Xerces::PerlErrorCallbackHandler->new();
@@ -5744,6 +5836,8 @@
*setValidationScheme = *XML::Xercesc::IDOMParser_setValidationScheme;
*setDoSchema = *XML::Xercesc::IDOMParser_setDoSchema;
*setValidationSchemaFullChecking = *XML::Xercesc::IDOMParser_setValidationSchemaFullChecking;
+*setExternalSchemaLocation = *XML::Xercesc::IDOMParser_setExternalSchemaLocation;
+*setExternalNoNamespaceSchemaLocation = *XML::Xercesc::IDOMParser_setExternalNoNamespaceSchemaLocation;
sub parse {
my @args = @_;
if (ref $args[1]) {
@@ -5764,6 +5858,60 @@
*parseReset = *XML::Xercesc::IDOMParser_parseReset;
*error = *XML::Xercesc::IDOMParser_error;
*resetErrors = *XML::Xercesc::IDOMParser_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::Grammar ##############
+
+package XML::Xerces::Grammar;
+@ISA = qw( XML::Xerces );
+%OWNER = ();
+%ITERATORS = ();
+*DTDGrammarType = *XML::Xercesc::Grammar_DTDGrammarType;
+*SchemaGrammarType = *XML::Xercesc::Grammar_SchemaGrammarType;
+*UNKNOWN_SCOPE = *XML::Xercesc::Grammar_UNKNOWN_SCOPE;
+*TOP_LEVEL_SCOPE = *XML::Xercesc::Grammar_TOP_LEVEL_SCOPE;
+
+*getGrammarType = *XML::Xercesc::Grammar_getGrammarType;
+*getTargetNamespace = *XML::Xercesc::Grammar_getTargetNamespace;
+sub findOrAddElemDecl {
+ my @args = @_;
+ my $result = XML::Xercesc::Grammar_findOrAddElemDecl(@args);
+ return $result unless ref($result) =~ m[XML::Xerces];
+ my %resulthash;
+ tie %resulthash, ref($result), $result;
+ return bless \%resulthash, ref($result);
+}
+*getElemId = *XML::Xercesc::Grammar_getElemId;
+sub getElemDecl {
+ my @args = @_;
+ my $result = XML::Xercesc::Grammar_getElemDecl(@args);
+ return $result unless ref($result) =~ m[XML::Xerces];
+ my %resulthash;
+ tie %resulthash, ref($result), $result;
+ return bless \%resulthash, ref($result);
+}
+*getNotationDecl = *XML::Xercesc::Grammar_getNotationDecl;
+sub putElemDecl {
+ my @args = @_;
+ my $result = XML::Xercesc::Grammar_putElemDecl(@args);
+ return $result unless ref($result) =~ m[XML::Xerces];
+ my %resulthash;
+ tie %resulthash, ref($result), $result;
+ return bless \%resulthash, ref($result);
+}
+*putNotationDecl = *XML::Xercesc::Grammar_putNotationDecl;
+*reset = *XML::Xercesc::Grammar_reset;
sub DISOWN {
my $self = shift;
my $ptr = tied(%$self);
---------------------------------------------------------------------
To unsubscribe, e-mail: xerces-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: xerces-cvs-help@xml.apache.org