more fixes and extending the tests coverage adding a type init interface
* gentest.py testapi.c: more fixes and extending the tests coverage
* relaxng.c include/libxml/relaxng.h: adding a type init interface
* include/libxml/xmlerror.h parser.c xmlreader.c xmlwriter.c: more
cleanups and bug fixes raised by the regression tests
Daniel
diff --git a/ChangeLog b/ChangeLog
index 3b476de..8065f92 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+Wed Nov 3 15:19:22 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+ * gentest.py testapi.c: more fixes and extending the tests coverage
+ * relaxng.c include/libxml/relaxng.h: adding a type init interface
+ * include/libxml/xmlerror.h parser.c xmlreader.c xmlwriter.c: more
+ cleanups and bug fixes raised by the regression tests
+
Wed Nov 3 12:49:30 CET 2004 Daniel Veillard <daniel@veillard.com>
* gentest.py testapi.c: more fixes and extending the tests coverage
diff --git a/gentest.py b/gentest.py
index 45bedfa..50fa34d 100755
--- a/gentest.py
+++ b/gentest.py
@@ -15,14 +15,25 @@
#
skipped_modules = [ "SAX", "SAX2", "xlink", "threads", "globals",
"xpathInternals", "xmlunicode", "parserInternals", "xmlmemory",
- "xmlversion", "debugXML" ]
+ "xmlversion", "debugXML", "xmlexports" ]
#
# Some function really need to be skipped for the tests.
#
-skipped_functions = [ "xmlFdRead", "xmlReadFd", "xmlCtxtReadFd",
- "htmlFdRead", "htmlReadFd", "htmlCtxtReadFd",
- "xmlCleanupParser", "xmlStrcat", "xmlStrncat" ]
+skipped_functions = [
+# block on I/O
+"xmlFdRead", "xmlReadFd", "xmlCtxtReadFd",
+"htmlFdRead", "htmlReadFd", "htmlCtxtReadFd",
+"xmlReaderNewFd",
+# library state cleanup, generate false leak informations and other
+# troubles, heavillyb tested otherwise.
+"xmlCleanupParser", "xmlRelaxNGCleanupTypes",
+# hard to avoid leaks in the tests
+"xmlStrcat", "xmlStrncat",
+# unimplemented
+"xmlTextReaderReadInnerXml", "xmlTextReaderReadOuterXml",
+"xmlTextReaderReadString"
+]
#
# Those functions have side effect on the global state
@@ -141,6 +152,7 @@
int blocks, mem;
xmlInitParser();
+ xmlRelaxNGInitTypes();
LIBXML_TEST_VERSION
@@ -236,7 +248,7 @@
known_param_types = [ "int", "const_char_ptr", "const_xmlChar_ptr",
"xmlParserCtxtPtr", "xmlDocPtr", "filepath", "fileoutput",
"xmlNodePtr", "xmlNodePtr_in", "userdata", "xmlChar_ptr",
- "xmlTextWriterPtr" ];
+ "xmlTextWriterPtr", "xmlTextReaderPtr" ];
def is_known_param_type(name):
for type in known_param_types:
@@ -379,6 +391,17 @@
if (val != NULL) xmlFreeTextWriter(val);
}
+#define gen_nb_xmlTextReaderPtr 4
+static xmlTextReaderPtr gen_xmlTextReaderPtr(int no) {
+ if (no == 0) return(xmlNewTextReaderFilename("test/ent2"));
+ if (no == 1) return(xmlNewTextReaderFilename("test/valid/REC-xml-19980210.xml"));
+ if (no == 2) return(xmlNewTextReaderFilename("test/valid/dtds/xhtml1-strict.dtd"));
+ return(NULL);
+}
+static void des_xmlTextReaderPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderPtr val) {
+ if (val != NULL) xmlFreeTextReader(val);
+}
+
""");
#
diff --git a/include/libxml/relaxng.h b/include/libxml/relaxng.h
index 3254400..ca3c13b 100644
--- a/include/libxml/relaxng.h
+++ b/include/libxml/relaxng.h
@@ -94,6 +94,12 @@
XML_RELAXNGP_FREE_DOC = 1,
XML_RELAXNGP_CRNG = 2
} xmlRelaxNGParserFlag;
+
+XMLPUBFUN int XMLCALL
+ xmlRelaxNGInitTypes (void);
+XMLPUBFUN void XMLCALL
+ xmlRelaxNGCleanupTypes (void);
+
/*
* Interfaces for parsing.
*/
@@ -153,8 +159,6 @@
XMLPUBFUN int XMLCALL
xmlRelaxNGValidateDoc (xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc);
-XMLPUBFUN void XMLCALL
- xmlRelaxNGCleanupTypes (void);
/*
* Interfaces for progressive validation when possible
*/
diff --git a/include/libxml/xmlerror.h b/include/libxml/xmlerror.h
index d893369..29fe748 100644
--- a/include/libxml/xmlerror.h
+++ b/include/libxml/xmlerror.h
@@ -58,7 +58,8 @@
XML_FROM_C14N, /* The Canonicalization module */
XML_FROM_XSLT, /* The XSLT engine from libxslt */
XML_FROM_VALID, /* The XML DTD validation with valid context */
- XML_FROM_CHECK /* The error checking module */
+ XML_FROM_CHECK, /* The error checking module */
+ XML_FROM_WRITER /* The xmlwriter module */
} xmlErrorDomain;
/**
diff --git a/parser.c b/parser.c
index 7a51c05..22c4f6a 100644
--- a/parser.c
+++ b/parser.c
@@ -12117,6 +12117,7 @@
#endif
#ifdef LIBXML_SCHEMAS_ENABLED
xmlSchemaCleanupTypes();
+ xmlRelaxNGCleanupTypes();
#endif
xmlCleanupGlobals();
xmlResetLastError();
diff --git a/relaxng.c b/relaxng.c
index ae6c63d..146e9ea 100644
--- a/relaxng.c
+++ b/relaxng.c
@@ -2781,7 +2781,7 @@
*
* Returns 0 in case of success and -1 in case of error.
*/
-static int
+int
xmlRelaxNGInitTypes(void)
{
if (xmlRelaxNGTypeInitialized != 0)
diff --git a/testapi.c b/testapi.c
index f4ba296..f227a8a 100644
--- a/testapi.c
+++ b/testapi.c
@@ -29,6 +29,7 @@
int blocks, mem;
xmlInitParser();
+ xmlRelaxNGInitTypes();
LIBXML_TEST_VERSION
@@ -70,7 +71,6 @@
#include <libxml/xmlIO.h>
#include <libxml/xmlautomata.h>
#include <libxml/xmlerror.h>
-#include <libxml/xmlexports.h>
#include <libxml/xmlreader.h>
#include <libxml/xmlregexp.h>
#include <libxml/xmlsave.h>
@@ -103,7 +103,6 @@
static int test_xmlIO(void);
static int test_xmlautomata(void);
static int test_xmlerror(void);
-static int test_xmlexports(void);
static int test_xmlreader(void);
static int test_xmlregexp(void);
static int test_xmlsave(void);
@@ -248,6 +247,17 @@
if (val != NULL) xmlFreeTextWriter(val);
}
+#define gen_nb_xmlTextReaderPtr 4
+static xmlTextReaderPtr gen_xmlTextReaderPtr(int no) {
+ if (no == 0) return(xmlNewTextReaderFilename("test/ent2"));
+ if (no == 1) return(xmlNewTextReaderFilename("test/valid/REC-xml-19980210.xml"));
+ if (no == 2) return(xmlNewTextReaderFilename("test/valid/dtds/xhtml1-strict.dtd"));
+ return(NULL);
+}
+static void des_xmlTextReaderPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderPtr val) {
+ if (val != NULL) xmlFreeTextReader(val);
+}
+
static void desret_int(int val ATTRIBUTE_UNUSED) {
}
@@ -301,7 +311,6 @@
ret += test_xmlIO();
ret += test_xmlautomata();
ret += test_xmlerror();
- ret += test_xmlexports();
ret += test_xmlreader();
ret += test_xmlregexp();
ret += test_xmlsave();
@@ -5842,30 +5851,6 @@
}
static int
-test_xmlRelaxNGCleanupTypes(void) {
- int ret = 0;
-
-#ifdef LIBXML_SCHEMAS_ENABLED
- int mem_base;
-
- mem_base = xmlMemBlocks();
-
- xmlRelaxNGCleanupTypes();
- call_tests++;
- xmlResetLastError();
- if (mem_base != xmlMemBlocks()) {
- printf("Leak of %d blocks found in xmlRelaxNGCleanupTypes",
- xmlMemBlocks() - mem_base);
- ret++;
- printf("\n");
- }
-#endif
-
- return(ret);
-}
-
-
-static int
test_xmlRelaxNGDump(void) {
int ret = 0;
@@ -6039,7 +6024,6 @@
int ret = 0;
printf("Testing relaxng ...\n");
- ret += test_xmlRelaxNGCleanupTypes();
ret += test_xmlRelaxNGDump();
ret += test_xmlRelaxNGDumpTree();
ret += test_xmlRelaxNGGetParserErrors();
@@ -11817,16 +11801,6 @@
printf("Module xmlerror: %d errors\n", ret);
return(ret);
}
-static int
-test_xmlexports(void) {
- int ret = 0;
-
- printf("Testing xmlexports ...\n");
-
- if (ret != 0)
- printf("Module xmlexports: %d errors\n", ret);
- return(ret);
-}
static int
test_xmlNewTextReader(void) {
@@ -11902,18 +11876,59 @@
test_xmlReaderNewDoc(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* an XML reader */
+ int n_reader;
+ const xmlChar * cur; /* a pointer to a zero terminated string */
+ int n_cur;
+ const char * URL; /* the base URL to use for the document */
+ int n_URL;
+ const char * encoding; /* the document encoding, or NULL */
+ int n_encoding;
+ int options; /* a combination of xmlParserOption */
+ int n_options;
- /* missing type support */
- return(ret);
-}
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
+ for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
+ for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
+ for (n_options = 0;n_options < gen_nb_int;n_options++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ cur = gen_const_xmlChar_ptr(n_cur);
+ URL = gen_filepath(n_URL);
+ encoding = gen_const_char_ptr(n_encoding);
+ options = gen_int(n_options);
+ ret_val = xmlReaderNewDoc(reader, cur, URL, encoding, options);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_const_xmlChar_ptr(n_cur, cur);
+ des_filepath(n_URL, URL);
+ des_const_char_ptr(n_encoding, encoding);
+ des_int(n_options, options);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlReaderNewDoc",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_cur);
+ printf(" %d", n_URL);
+ printf(" %d", n_encoding);
+ printf(" %d", n_options);
+ printf("\n");
+ }
+ }
+ }
+ }
+ }
+ }
+#endif
-static int
-test_xmlReaderNewFd(void) {
- int ret = 0;
-
-
- /* missing type support */
return(ret);
}
@@ -11922,8 +11937,52 @@
test_xmlReaderNewFile(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* an XML reader */
+ int n_reader;
+ const char * filename; /* a file or URL */
+ int n_filename;
+ const char * encoding; /* the document encoding, or NULL */
+ int n_encoding;
+ int options; /* a combination of xmlParserOption */
+ int n_options;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
+ for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
+ for (n_options = 0;n_options < gen_nb_int;n_options++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ filename = gen_filepath(n_filename);
+ encoding = gen_const_char_ptr(n_encoding);
+ options = gen_int(n_options);
+
+ ret_val = xmlReaderNewFile(reader, filename, encoding, options);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_filepath(n_filename, filename);
+ des_const_char_ptr(n_encoding, encoding);
+ des_int(n_options, options);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlReaderNewFile",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_filename);
+ printf(" %d", n_encoding);
+ printf(" %d", n_options);
+ printf("\n");
+ }
+ }
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -11942,8 +12001,66 @@
test_xmlReaderNewMemory(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* an XML reader */
+ int n_reader;
+ const char * buffer; /* a pointer to a char array */
+ int n_buffer;
+ int size; /* the size of the array */
+ int n_size;
+ const char * URL; /* the base URL to use for the document */
+ int n_URL;
+ const char * encoding; /* the document encoding, or NULL */
+ int n_encoding;
+ int options; /* a combination of xmlParserOption */
+ int n_options;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
+ for (n_size = 0;n_size < gen_nb_int;n_size++) {
+ for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
+ for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
+ for (n_options = 0;n_options < gen_nb_int;n_options++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ buffer = gen_const_char_ptr(n_buffer);
+ size = gen_int(n_size);
+ URL = gen_filepath(n_URL);
+ encoding = gen_const_char_ptr(n_encoding);
+ options = gen_int(n_options);
+
+ ret_val = xmlReaderNewMemory(reader, buffer, size, URL, encoding, options);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_const_char_ptr(n_buffer, buffer);
+ des_int(n_size, size);
+ des_filepath(n_URL, URL);
+ des_const_char_ptr(n_encoding, encoding);
+ des_int(n_options, options);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlReaderNewMemory",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_buffer);
+ printf(" %d", n_size);
+ printf(" %d", n_URL);
+ printf(" %d", n_encoding);
+ printf(" %d", n_options);
+ printf("\n");
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -11952,8 +12069,38 @@
test_xmlReaderNewWalker(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* an XML reader */
+ int n_reader;
+ xmlDocPtr doc; /* a preparsed document */
+ int n_doc;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ doc = gen_xmlDocPtr(n_doc);
+
+ ret_val = xmlReaderNewWalker(reader, doc);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_xmlDocPtr(n_doc, doc);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlReaderNewWalker",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_doc);
+ printf("\n");
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -11972,8 +12119,31 @@
test_xmlTextReaderAttributeCount(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderAttributeCount(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderAttributeCount",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -11982,8 +12152,31 @@
test_xmlTextReaderBaseUri(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlChar * ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderBaseUri(reader);
+ desret_xmlChar_ptr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderBaseUri",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -11992,8 +12185,31 @@
test_xmlTextReaderClose(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderClose(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderClose",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12102,8 +12318,31 @@
test_xmlTextReaderCurrentDoc(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlDocPtr ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderCurrentDoc(reader);
+ desret_xmlDocPtr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderCurrentDoc",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12112,8 +12351,31 @@
test_xmlTextReaderCurrentNode(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlNodePtr ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderCurrentNode(reader);
+ desret_xmlNodePtr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderCurrentNode",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12122,8 +12384,31 @@
test_xmlTextReaderDepth(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderDepth(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderDepth",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12132,8 +12417,31 @@
test_xmlTextReaderExpand(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlNodePtr ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderExpand(reader);
+ desret_xmlNodePtr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderExpand",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12142,8 +12450,38 @@
test_xmlTextReaderGetAttribute(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlChar * ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
+ const xmlChar * name; /* the qualified name of the attribute. */
+ int n_name;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ name = gen_const_xmlChar_ptr(n_name);
+
+ ret_val = xmlTextReaderGetAttribute(reader, name);
+ desret_xmlChar_ptr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_const_xmlChar_ptr(n_name, name);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderGetAttribute",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_name);
+ printf("\n");
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -12152,8 +12490,38 @@
test_xmlTextReaderGetAttributeNo(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlChar * ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
+ int no; /* the zero-based index of the attribute relative to the containing element */
+ int n_no;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_no = 0;n_no < gen_nb_int;n_no++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ no = gen_int(n_no);
+
+ ret_val = xmlTextReaderGetAttributeNo(reader, no);
+ desret_xmlChar_ptr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_int(n_no, no);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderGetAttributeNo",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_no);
+ printf("\n");
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -12162,8 +12530,45 @@
test_xmlTextReaderGetAttributeNs(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlChar * ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
+ const xmlChar * localName; /* the local name of the attribute. */
+ int n_localName;
+ const xmlChar * namespaceURI; /* the namespace URI of the attribute. */
+ int n_namespaceURI;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
+ for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ localName = gen_const_xmlChar_ptr(n_localName);
+ namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI);
+
+ ret_val = xmlTextReaderGetAttributeNs(reader, localName, namespaceURI);
+ desret_xmlChar_ptr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_const_xmlChar_ptr(n_localName, localName);
+ des_const_xmlChar_ptr(n_namespaceURI, namespaceURI);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderGetAttributeNs",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_localName);
+ printf(" %d", n_namespaceURI);
+ printf("\n");
+ }
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -12182,8 +12587,38 @@
test_xmlTextReaderGetParserProp(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
+ int prop; /* the xmlParserProperties to get */
+ int n_prop;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ prop = gen_int(n_prop);
+
+ ret_val = xmlTextReaderGetParserProp(reader, prop);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_int(n_prop, prop);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderGetParserProp",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_prop);
+ printf("\n");
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -12202,8 +12637,31 @@
test_xmlTextReaderHasAttributes(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderHasAttributes(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderHasAttributes",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12212,8 +12670,31 @@
test_xmlTextReaderHasValue(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderHasValue(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderHasValue",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12222,8 +12703,31 @@
test_xmlTextReaderIsDefault(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderIsDefault(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderIsDefault",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12232,8 +12736,31 @@
test_xmlTextReaderIsEmptyElement(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderIsEmptyElement(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderIsEmptyElement",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12242,8 +12769,31 @@
test_xmlTextReaderIsNamespaceDecl(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderIsNamespaceDecl(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderIsNamespaceDecl",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12252,8 +12802,31 @@
test_xmlTextReaderIsValid(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderIsValid(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderIsValid",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12262,8 +12835,31 @@
test_xmlTextReaderLocalName(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlChar * ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderLocalName(reader);
+ desret_xmlChar_ptr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderLocalName",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12292,8 +12888,38 @@
test_xmlTextReaderLookupNamespace(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlChar * ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
+ const xmlChar * prefix; /* the prefix whose namespace URI is to be resolved. To return the default namespace, specify NULL */
+ int n_prefix;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ prefix = gen_const_xmlChar_ptr(n_prefix);
+
+ ret_val = xmlTextReaderLookupNamespace(reader, prefix);
+ desret_xmlChar_ptr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_const_xmlChar_ptr(n_prefix, prefix);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderLookupNamespace",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_prefix);
+ printf("\n");
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -12302,8 +12928,38 @@
test_xmlTextReaderMoveToAttribute(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
+ const xmlChar * name; /* the qualified name of the attribute. */
+ int n_name;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ name = gen_const_xmlChar_ptr(n_name);
+
+ ret_val = xmlTextReaderMoveToAttribute(reader, name);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_const_xmlChar_ptr(n_name, name);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderMoveToAttribute",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_name);
+ printf("\n");
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -12312,8 +12968,38 @@
test_xmlTextReaderMoveToAttributeNo(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
+ int no; /* the zero-based index of the attribute relative to the containing element. */
+ int n_no;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_no = 0;n_no < gen_nb_int;n_no++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ no = gen_int(n_no);
+
+ ret_val = xmlTextReaderMoveToAttributeNo(reader, no);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_int(n_no, no);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNo",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_no);
+ printf("\n");
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -12322,8 +13008,45 @@
test_xmlTextReaderMoveToAttributeNs(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
+ const xmlChar * localName; /* the local name of the attribute. */
+ int n_localName;
+ const xmlChar * namespaceURI; /* the namespace URI of the attribute. */
+ int n_namespaceURI;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
+ for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ localName = gen_const_xmlChar_ptr(n_localName);
+ namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI);
+
+ ret_val = xmlTextReaderMoveToAttributeNs(reader, localName, namespaceURI);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_const_xmlChar_ptr(n_localName, localName);
+ des_const_xmlChar_ptr(n_namespaceURI, namespaceURI);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNs",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_localName);
+ printf(" %d", n_namespaceURI);
+ printf("\n");
+ }
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -12332,8 +13055,31 @@
test_xmlTextReaderMoveToElement(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderMoveToElement(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderMoveToElement",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12342,8 +13088,31 @@
test_xmlTextReaderMoveToFirstAttribute(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderMoveToFirstAttribute(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderMoveToFirstAttribute",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12352,8 +13121,31 @@
test_xmlTextReaderMoveToNextAttribute(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderMoveToNextAttribute(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderMoveToNextAttribute",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12362,8 +13154,31 @@
test_xmlTextReaderName(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlChar * ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderName(reader);
+ desret_xmlChar_ptr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderName",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12372,8 +13187,31 @@
test_xmlTextReaderNamespaceUri(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlChar * ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderNamespaceUri(reader);
+ desret_xmlChar_ptr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderNamespaceUri",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12382,8 +13220,31 @@
test_xmlTextReaderNext(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderNext(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderNext",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12392,8 +13253,31 @@
test_xmlTextReaderNextSibling(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderNextSibling(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderNextSibling",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12402,8 +13286,31 @@
test_xmlTextReaderNodeType(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderNodeType(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderNodeType",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12412,8 +13319,31 @@
test_xmlTextReaderNormalization(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderNormalization(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderNormalization",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12422,8 +13352,31 @@
test_xmlTextReaderPrefix(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlChar * ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderPrefix(reader);
+ desret_xmlChar_ptr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderPrefix",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12432,8 +13385,31 @@
test_xmlTextReaderPreserve(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlNodePtr ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderPreserve(reader);
+ desret_xmlNodePtr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderPreserve",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12452,8 +13428,31 @@
test_xmlTextReaderQuoteChar(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderQuoteChar(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderQuoteChar",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12462,8 +13461,31 @@
test_xmlTextReaderRead(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderRead(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderRead",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12472,28 +13494,31 @@
test_xmlTextReaderReadAttributeValue(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
- return(ret);
-}
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ ret_val = xmlTextReaderReadAttributeValue(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderReadAttributeValue",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
-static int
-test_xmlTextReaderReadInnerXml(void) {
- int ret = 0;
-
-
- /* missing type support */
- return(ret);
-}
-
-
-static int
-test_xmlTextReaderReadOuterXml(void) {
- int ret = 0;
-
-
- /* missing type support */
return(ret);
}
@@ -12502,18 +13527,31 @@
test_xmlTextReaderReadState(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
- return(ret);
-}
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ ret_val = xmlTextReaderReadState(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderReadState",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
-static int
-test_xmlTextReaderReadString(void) {
- int ret = 0;
-
-
- /* missing type support */
return(ret);
}
@@ -12532,8 +13570,40 @@
test_xmlTextReaderRelaxNGValidate(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+#ifdef LIBXML_SCHEMAS_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
+ const char * rng; /* the path to a RelaxNG schema or NULL */
+ int n_rng;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_rng = 0;n_rng < gen_nb_const_char_ptr;n_rng++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ rng = gen_const_char_ptr(n_rng);
+
+ ret_val = xmlTextReaderRelaxNGValidate(reader, rng);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_const_char_ptr(n_rng, rng);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidate",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_rng);
+ printf("\n");
+ }
+ }
+ }
+#endif
+#endif
+
return(ret);
}
@@ -12552,8 +13622,45 @@
test_xmlTextReaderSetParserProp(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
+ int prop; /* the xmlParserProperties to set */
+ int n_prop;
+ int value; /* usually 0 or 1 to (de)activate it */
+ int n_value;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
+ for (n_value = 0;n_value < gen_nb_int;n_value++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+ prop = gen_int(n_prop);
+ value = gen_int(n_value);
+
+ ret_val = xmlTextReaderSetParserProp(reader, prop, value);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ des_int(n_prop, prop);
+ des_int(n_value, value);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderSetParserProp",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf(" %d", n_prop);
+ printf(" %d", n_value);
+ printf("\n");
+ }
+ }
+ }
+ }
+#endif
+
return(ret);
}
@@ -12572,8 +13679,31 @@
test_xmlTextReaderStandalone(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ int ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderStandalone(reader);
+ desret_int(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderStandalone",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12582,8 +13712,31 @@
test_xmlTextReaderValue(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlChar * ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderValue(reader);
+ desret_xmlChar_ptr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderValue",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12592,8 +13745,31 @@
test_xmlTextReaderXmlLang(void) {
int ret = 0;
+#ifdef LIBXML_READER_ENABLED
+ int mem_base;
+ xmlChar * ret_val;
+ xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
+ int n_reader;
- /* missing type support */
+ for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
+ mem_base = xmlMemBlocks();
+ reader = gen_xmlTextReaderPtr(n_reader);
+
+ ret_val = xmlTextReaderXmlLang(reader);
+ desret_xmlChar_ptr(ret_val);
+ call_tests++;
+ des_xmlTextReaderPtr(n_reader, reader);
+ xmlResetLastError();
+ if (mem_base != xmlMemBlocks()) {
+ printf("Leak of %d blocks found in xmlTextReaderXmlLang",
+ xmlMemBlocks() - mem_base);
+ ret++;
+ printf(" %d", n_reader);
+ printf("\n");
+ }
+ }
+#endif
+
return(ret);
}
@@ -12610,7 +13786,6 @@
ret += test_xmlReaderForIO();
ret += test_xmlReaderForMemory();
ret += test_xmlReaderNewDoc();
- ret += test_xmlReaderNewFd();
ret += test_xmlReaderNewFile();
ret += test_xmlReaderNewIO();
ret += test_xmlReaderNewMemory();
@@ -12667,10 +13842,7 @@
ret += test_xmlTextReaderQuoteChar();
ret += test_xmlTextReaderRead();
ret += test_xmlTextReaderReadAttributeValue();
- ret += test_xmlTextReaderReadInnerXml();
- ret += test_xmlTextReaderReadOuterXml();
ret += test_xmlTextReaderReadState();
- ret += test_xmlTextReaderReadString();
ret += test_xmlTextReaderRelaxNGSetSchema();
ret += test_xmlTextReaderRelaxNGValidate();
ret += test_xmlTextReaderSetErrorHandler();
diff --git a/xmlreader.c b/xmlreader.c
index e3243b9..f998ba2 100644
--- a/xmlreader.c
+++ b/xmlreader.c
@@ -1825,7 +1825,7 @@
if (reader == NULL)
return(-1);
if (reader->doc == NULL) {
- TODO
+ /* TODO */
return(-1);
}
@@ -4629,6 +4629,9 @@
if (reader == NULL)
return (-1);
+ if (reader->input != NULL) {
+ xmlFreeParserInputBuffer(reader->input);
+ }
if (reader->ctxt != NULL) {
xmlCtxtReset(reader->ctxt);
}
diff --git a/xmlwriter.c b/xmlwriter.c
index d4c7176..a11ef25 100644
--- a/xmlwriter.c
+++ b/xmlwriter.c
@@ -96,6 +96,51 @@
xmlTextWriterStackEntry * p);
/**
+ * xmlWriterErrMsg:
+ * @ctxt: a writer context
+ * @error: the error number
+ * @msg: the error message
+ *
+ * Handle a writer error
+ */
+static void
+xmlWriterErrMsg(xmlTextWriterPtr ctxt, xmlParserErrors error,
+ const char *msg)
+{
+ if (ctxt != NULL) {
+ __xmlRaiseError(NULL, NULL, NULL, ctxt->ctxt,
+ NULL, XML_FROM_WRITER, error, XML_ERR_FATAL,
+ NULL, 0, NULL, NULL, NULL, 0, 0, msg);
+ } else {
+ __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_WRITER, error,
+ XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, msg);
+ }
+}
+
+/**
+ * xmlWriterErrMsgInt:
+ * @ctxt: a writer context
+ * @error: the error number
+ * @msg: the error message
+ * @val: an int
+ *
+ * Handle a writer error
+ */
+static void
+xmlWriterErrMsgInt(xmlTextWriterPtr ctxt, xmlParserErrors error,
+ const char *msg, int val)
+{
+ if (ctxt != NULL) {
+ __xmlRaiseError(NULL, NULL, NULL, ctxt->ctxt,
+ NULL, XML_FROM_WRITER, error, XML_ERR_FATAL,
+ NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
+ } else {
+ __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_WRITER, error,
+ XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
+ }
+}
+
+/**
* xmlNewTextWriter:
* @out: an xmlOutputBufferPtr
*
@@ -110,7 +155,7 @@
ret = (xmlTextWriterPtr) xmlMalloc(sizeof(xmlTextWriter));
if (ret == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriter : out of memory!\n");
return NULL;
}
@@ -121,7 +166,7 @@
(xmlListDataCompare)
xmlCmpTextWriterStackEntry);
if (ret->nodes == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriter : out of memory!\n");
xmlFree(ret);
return NULL;
@@ -132,7 +177,7 @@
(xmlListDataCompare)
xmlCmpTextWriterNsStackEntry);
if (ret->nsstack == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriter : out of memory!\n");
xmlListDelete(ret->nodes);
xmlFree(ret);
@@ -147,7 +192,7 @@
xmlListDelete(ret->nodes);
xmlListDelete(ret->nsstack);
xmlFree(ret);
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriter : out of memory!\n");
return NULL;
}
@@ -172,14 +217,14 @@
out = xmlOutputBufferCreateFilename(uri, NULL, compression);
if (out == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriterFilename : out of memory!\n");
return NULL;
}
ret = xmlNewTextWriter(out);
if (ret == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriterFilename : out of memory!\n");
xmlOutputBufferClose(out);
return NULL;
@@ -213,14 +258,14 @@
xmlTextWriterCloseMemCallback,
(void *) buf, NULL);
if (out == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriterMemory : out of memory!\n");
return NULL;
}
ret = xmlNewTextWriter(out);
if (ret == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriterMemory : out of memory!\n");
xmlOutputBufferClose(out);
return NULL;
@@ -247,7 +292,7 @@
xmlOutputBufferPtr out;
if (ctxt == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterPushParser : invalid context!\n");
return NULL;
}
@@ -258,14 +303,14 @@
xmlTextWriterCloseDocCallback,
(void *) ctxt, NULL);
if (out == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterPushParser : error at xmlOutputBufferCreateIO!\n");
return NULL;
}
ret = xmlNewTextWriter(out);
if (ret == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterPushParser : error at xmlNewTextWriter!\n");
xmlOutputBufferClose(out);
return NULL;
@@ -300,7 +345,7 @@
ctxt = xmlCreatePushParserCtxt(&saxHandler, NULL, NULL, 0, NULL);
if (ctxt == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterDoc : error at xmlCreatePushParserCtxt!\n");
return NULL;
}
@@ -313,14 +358,14 @@
ctxt->myDoc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
if (ctxt->myDoc == NULL) {
xmlFreeParserCtxt(ctxt);
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterDoc : error at xmlNewDoc!\n");
return NULL;
}
ret = xmlNewTextWriterPushParser(ctxt, compression);
if (ret == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterDoc : error at xmlNewTextWriterPushParser!\n");
return NULL;
}
@@ -352,7 +397,7 @@
xmlParserCtxtPtr ctxt;
if (doc == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterTree : invalid document tree!\n");
return NULL;
}
@@ -365,7 +410,7 @@
ctxt = xmlCreatePushParserCtxt(&saxHandler, NULL, NULL, 0, NULL);
if (ctxt == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterDoc : error at xmlCreatePushParserCtxt!\n");
return NULL;
}
@@ -378,7 +423,7 @@
ret = xmlNewTextWriterPushParser(ctxt, compression);
if (ret == NULL) {
xmlFreeParserCtxt(ctxt);
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterDoc : error at xmlNewTextWriterPushParser!\n");
return NULL;
}
@@ -441,14 +486,14 @@
xmlCharEncodingHandlerPtr encoder;
if ((writer == NULL) || (writer->out == NULL)) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartDocument : invalid writer!\n");
return -1;
}
lk = xmlListFront(writer->nodes);
if ((lk != NULL) && (xmlLinkGetData(lk) != NULL)) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartDocument : not allowed in this context!\n");
return -1;
}
@@ -457,7 +502,7 @@
if (encoding != NULL) {
encoder = xmlFindCharEncodingHandler(encoding);
if (encoder == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDocument : out of memory!\n");
return -1;
}
@@ -555,7 +600,7 @@
xmlTextWriterStackEntry *p;
if (writer == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterEndDocument : invalid writer!\n");
return -1;
}
@@ -638,7 +683,7 @@
xmlTextWriterStackEntry *p;
if (writer == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartComment : invalid writer!\n");
return -1;
}
@@ -675,7 +720,7 @@
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartElement : out of memory!\n");
return -1;
}
@@ -717,14 +762,14 @@
xmlTextWriterStackEntry *p;
if (writer == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterEndComment : invalid writer!\n");
return -1;
}
lk = xmlListFront(writer->nodes);
if (lk == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterEndComment : not allowed in this context!\n");
return -1;
}
@@ -799,7 +844,7 @@
xmlChar *buf;
if (writer == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteVFormatComment : invalid writer!\n");
return -1;
}
@@ -896,14 +941,14 @@
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartElement : out of memory!\n");
return -1;
}
p->name = xmlStrdup(name);
if (p->name == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartElement : out of memory!\n");
xmlFree(p);
return -1;
@@ -1201,13 +1246,13 @@
xmlTextWriterStackEntry *p;
if (writer == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteRawLen : invalid writer!\n");
return -1;
}
if ((content == NULL) || (len < 0)) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteRawLen : invalid content!\n");
return -1;
}
@@ -1704,7 +1749,7 @@
p = (xmlTextWriterNsStackEntry *)
xmlMalloc(sizeof(xmlTextWriterNsStackEntry));
if (p == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartAttributeNS : out of memory!\n");
return -1;
}
@@ -1712,7 +1757,7 @@
p->prefix = buf;
p->uri = xmlStrdup(namespaceURI);
if (p->uri == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartAttributeNS : out of memory!\n");
xmlFree(p);
return -1;
@@ -2241,7 +2286,7 @@
return -1;
if (xmlStrcasecmp(target, (const xmlChar *) "xml") == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartPI : target name [Xx][Mm][Ll] is reserved for xml standardization!\n");
return -1;
}
@@ -2271,7 +2316,7 @@
break;
case XML_TEXTWRITER_PI:
case XML_TEXTWRITER_PI_TEXT:
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartPI : nested PI!\n");
return -1;
default:
@@ -2283,14 +2328,14 @@
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartPI : out of memory!\n");
return -1;
}
p->name = xmlStrdup(target);
if (p->name == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartPI : out of memory!\n");
xmlFree(p);
return -1;
@@ -2493,7 +2538,7 @@
p->state = XML_TEXTWRITER_TEXT;
break;
case XML_TEXTWRITER_CDATA:
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartCDATA : CDATA not allowed in this context!\n");
return -1;
default:
@@ -2505,7 +2550,7 @@
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartCDATA : out of memory!\n");
return -1;
}
@@ -2682,7 +2727,7 @@
sum = 0;
lk = xmlListFront(writer->nodes);
if ((lk != NULL) && (xmlLinkGetData(lk) != NULL)) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartDTD : DTD allowed only in prolog!\n");
return -1;
}
@@ -2690,14 +2735,14 @@
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTD : out of memory!\n");
return -1;
}
p->name = xmlStrdup(name);
if (p->name == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTD : out of memory!\n");
xmlFree(p);
return -1;
@@ -2717,7 +2762,7 @@
if (pubid != 0) {
if (sysid == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartDTD : system identifier needed!\n");
return -1;
}
@@ -3029,14 +3074,14 @@
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDElement : out of memory!\n");
return -1;
}
p->name = xmlStrdup(name);
if (p->name == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDElement : out of memory!\n");
xmlFree(p);
return -1;
@@ -3266,14 +3311,14 @@
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDAttlist : out of memory!\n");
return -1;
}
p->name = xmlStrdup(name);
if (p->name == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDAttlist : out of memory!\n");
xmlFree(p);
return -1;
@@ -3505,14 +3550,14 @@
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDElement : out of memory!\n");
return -1;
}
p->name = xmlStrdup(name);
if (p->name == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDElement : out of memory!\n");
xmlFree(p);
return -1;
@@ -3824,7 +3869,7 @@
xmlTextWriterStackEntry *p;
if (writer == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDTDExternalEntityContents: xmlTextWriterPtr invalid!\n");
return -1;
}
@@ -3832,7 +3877,7 @@
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDTDExternalEntityContents: you must call xmlTextWriterStartDTDEntity before the call to this function!\n");
return -1;
}
@@ -3846,20 +3891,20 @@
break;
case XML_TEXTWRITER_DTD_PENT:
if (ndataid != NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDTDExternalEntityContents: notation not allowed with parameter entities!\n");
return -1;
}
break;
default:
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDTDExternalEntityContents: you must call xmlTextWriterStartDTDEntity before the call to this function!\n");
return -1;
}
if (pubid != 0) {
if (sysid == 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDTDExternalEntityContents: system identifier needed!\n");
return -1;
}
@@ -4248,7 +4293,7 @@
int rc;
if ((rc = xmlParseChunk(ctxt, (const char *) str, len, 0)) != 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsgInt(NULL, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDocCallback : XML error %d !\n",
rc);
return -1;
@@ -4272,7 +4317,7 @@
int rc;
if ((rc = xmlParseChunk(ctxt, NULL, 0, 1)) != 0) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsgInt(NULL, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDocCallback : XML error %d !\n",
rc);
return -1;
@@ -4300,7 +4345,7 @@
size = BUFSIZ;
buf = (xmlChar *) xmlMalloc(size);
if (buf == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlTextWriterVSprintf : out of memory!\n");
return NULL;
}
@@ -4311,7 +4356,7 @@
size += BUFSIZ;
buf = (xmlChar *) xmlMalloc(size);
if (buf == NULL) {
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlTextWriterVSprintf : out of memory!\n");
return NULL;
}
@@ -4332,9 +4377,6 @@
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
xmlDocPtr doc;
-#ifdef DEBUG_SAX
- xmlGenericError(xmlGenericErrorContext, "SAX.startDocument()\n");
-#endif
if (ctxt->html) {
#ifdef LIBXML_HTML_ENABLED
if (ctxt->myDoc == NULL)
@@ -4349,7 +4391,7 @@
return;
}
#else
- xmlGenericError(xmlGenericErrorContext,
+ xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"libxml2 built without HTML support\n");
ctxt->errNo = XML_ERR_INTERNAL_ERROR;
ctxt->instate = XML_PARSER_EOF;