summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--HTMLparser.c2
-rw-r--r--catalog.c50
-rw-r--r--debugXML.c11
-rw-r--r--doc/symbols.xml3
-rw-r--r--entities.c21
-rw-r--r--hash.c19
-rw-r--r--include/libxml/hash.h9
-rw-r--r--parser.c2
-rw-r--r--parserInternals.c2
-rw-r--r--relaxng.c35
-rw-r--r--valid.c120
-rw-r--r--xinclude.c10
-rw-r--r--xmlreader.c7
-rw-r--r--xmlschemas.c58
-rw-r--r--xmlschemastypes.c7
-rw-r--r--xpath.c22
16 files changed, 235 insertions, 143 deletions
diff --git a/HTMLparser.c b/HTMLparser.c
index e4f816e5..d6971b5d 100644
--- a/HTMLparser.c
+++ b/HTMLparser.c
@@ -6674,7 +6674,7 @@ htmlCtxtReset(htmlParserCtxtPtr ctxt)
xmlInitNodeInfoSeq(&ctxt->node_seq);
if (ctxt->attsDefault != NULL) {
- xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
+ xmlHashFree(ctxt->attsDefault, xmlHashDefaultDeallocator);
ctxt->attsDefault = NULL;
}
if (ctxt->attsSpecial != NULL) {
diff --git a/catalog.c b/catalog.c
index f6186a1c..f814121c 100644
--- a/catalog.c
+++ b/catalog.c
@@ -319,12 +319,13 @@ xmlFreeCatalogEntryList(xmlCatalogEntryPtr ret);
/**
* xmlFreeCatalogEntry:
- * @ret: a Catalog entry
+ * @payload: a Catalog entry
*
* Free the memory allocated to a Catalog entry
*/
static void
-xmlFreeCatalogEntry(xmlCatalogEntryPtr ret) {
+xmlFreeCatalogEntry(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlCatalogEntryPtr ret = (xmlCatalogEntryPtr) payload;
if (ret == NULL)
return;
/*
@@ -367,20 +368,22 @@ xmlFreeCatalogEntryList(xmlCatalogEntryPtr ret) {
while (ret != NULL) {
next = ret->next;
- xmlFreeCatalogEntry(ret);
+ xmlFreeCatalogEntry(ret, NULL);
ret = next;
}
}
/**
* xmlFreeCatalogHashEntryList:
- * @ret: a Catalog entry list
+ * @payload: a Catalog entry list
*
* Free the memory allocated to list of Catalog entries from the
* catalog file hash.
*/
static void
-xmlFreeCatalogHashEntryList(xmlCatalogEntryPtr catal) {
+xmlFreeCatalogHashEntryList(void *payload,
+ const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlCatalogEntryPtr catal = (xmlCatalogEntryPtr) payload;
xmlCatalogEntryPtr children, next;
if (catal == NULL)
@@ -391,11 +394,11 @@ xmlFreeCatalogHashEntryList(xmlCatalogEntryPtr catal) {
next = children->next;
children->dealloc = 0;
children->children = NULL;
- xmlFreeCatalogEntry(children);
+ xmlFreeCatalogEntry(children, NULL);
children = next;
}
catal->dealloc = 0;
- xmlFreeCatalogEntry(catal);
+ xmlFreeCatalogEntry(catal, NULL);
}
/**
@@ -440,8 +443,7 @@ xmlFreeCatalog(xmlCatalogPtr catal) {
if (catal->xml != NULL)
xmlFreeCatalogEntryList(catal->xml);
if (catal->sgml != NULL)
- xmlHashFree(catal->sgml,
- (xmlHashDeallocator) xmlFreeCatalogEntry);
+ xmlHashFree(catal->sgml, xmlFreeCatalogEntry);
xmlFree(catal);
}
@@ -460,7 +462,10 @@ xmlFreeCatalog(xmlCatalogPtr catal) {
* Serialize an SGML Catalog entry
*/
static void
-xmlCatalogDumpEntry(xmlCatalogEntryPtr entry, FILE *out) {
+xmlCatalogDumpEntry(void *payload, void *data,
+ const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlCatalogEntryPtr entry = (xmlCatalogEntryPtr) payload;
+ FILE *out = (FILE *) data;
if ((entry == NULL) || (out == NULL))
return;
switch (entry->type) {
@@ -723,7 +728,10 @@ BAD_CAST "http://www.oasis-open.org/committees/entity/release/1.0/catalog.dtd");
* Convert one entry from the catalog
*/
static void
-xmlCatalogConvertEntry(xmlCatalogEntryPtr entry, xmlCatalogPtr catal) {
+xmlCatalogConvertEntry(void *payload, void *data,
+ const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlCatalogEntryPtr entry = (xmlCatalogEntryPtr) payload;
+ xmlCatalogPtr catal = (xmlCatalogPtr) data;
if ((entry == NULL) || (catal == NULL) || (catal->sgml == NULL) ||
(catal->xml == NULL))
return;
@@ -756,8 +764,7 @@ xmlCatalogConvertEntry(xmlCatalogEntryPtr entry, xmlCatalogPtr catal) {
entry->type = XML_CATA_CATALOG;
break;
default:
- xmlHashRemoveEntry(catal->sgml, entry->name,
- (xmlHashDeallocator) xmlFreeCatalogEntry);
+ xmlHashRemoveEntry(catal->sgml, entry->name, xmlFreeCatalogEntry);
return;
}
/*
@@ -797,9 +804,7 @@ xmlConvertSGMLCatalog(xmlCatalogPtr catal) {
xmlGenericError(xmlGenericErrorContext,
"Converting SGML catalog to XML\n");
}
- xmlHashScan(catal->sgml,
- (xmlHashScanner) xmlCatalogConvertEntry,
- &catal);
+ xmlHashScan(catal->sgml, xmlCatalogConvertEntry, &catal);
return(0);
}
@@ -2486,7 +2491,7 @@ xmlParseSGMLCatalog(xmlCatalogPtr catal, const xmlChar *value,
NULL, XML_CATA_PREFER_NONE, NULL);
res = xmlHashAddEntry(catal->sgml, name, entry);
if (res < 0) {
- xmlFreeCatalogEntry(entry);
+ xmlFreeCatalogEntry(entry, NULL);
}
xmlFree(filename);
}
@@ -2499,7 +2504,7 @@ xmlParseSGMLCatalog(xmlCatalogPtr catal, const xmlChar *value,
XML_CATA_PREFER_NONE, NULL);
res = xmlHashAddEntry(catal->sgml, sysid, entry);
if (res < 0) {
- xmlFreeCatalogEntry(entry);
+ xmlFreeCatalogEntry(entry, NULL);
}
} else {
xmlChar *filename;
@@ -2937,8 +2942,7 @@ xmlACatalogDump(xmlCatalogPtr catal, FILE *out) {
if (catal->type == XML_XML_CATALOG_TYPE) {
xmlDumpXMLCatalog(out, catal->xml);
} else {
- xmlHashScan(catal->sgml,
- (xmlHashScanner) xmlCatalogDumpEntry, out);
+ xmlHashScan(catal->sgml, xmlCatalogDumpEntry, out);
}
}
#endif /* LIBXML_OUTPUT_ENABLED */
@@ -3002,8 +3006,7 @@ xmlACatalogRemove(xmlCatalogPtr catal, const xmlChar *value) {
if (catal->type == XML_XML_CATALOG_TYPE) {
res = xmlDelXMLCatalog(catal->xml, value);
} else {
- res = xmlHashRemoveEntry(catal->sgml, value,
- (xmlHashDeallocator) xmlFreeCatalogEntry);
+ res = xmlHashRemoveEntry(catal->sgml, value, xmlFreeCatalogEntry);
if (res == 0)
res = 1;
}
@@ -3284,8 +3287,7 @@ xmlCatalogCleanup(void) {
xmlGenericError(xmlGenericErrorContext,
"Catalogs cleanup\n");
if (xmlCatalogXMLFiles != NULL)
- xmlHashFree(xmlCatalogXMLFiles,
- (xmlHashDeallocator)xmlFreeCatalogHashEntryList);
+ xmlHashFree(xmlCatalogXMLFiles, xmlFreeCatalogHashEntryList);
xmlCatalogXMLFiles = NULL;
if (xmlDefaultCatalog != NULL)
xmlFreeCatalog(xmlDefaultCatalog);
diff --git a/debugXML.c b/debugXML.c
index a8ec8a46..c98db0bc 100644
--- a/debugXML.c
+++ b/debugXML.c
@@ -1229,8 +1229,11 @@ xmlCtxtDumpDocument(xmlDebugCtxtPtr ctxt, xmlDocPtr doc)
}
static void
-xmlCtxtDumpEntityCallback(xmlEntityPtr cur, xmlDebugCtxtPtr ctxt)
+xmlCtxtDumpEntityCallback(void *payload, void *data,
+ const xmlChar *name ATTRIBUTE_UNUSED)
{
+ xmlEntityPtr cur = (xmlEntityPtr) payload;
+ xmlDebugCtxtPtr ctxt = (xmlDebugCtxtPtr) data;
if (cur == NULL) {
if (!ctxt->check)
fprintf(ctxt->output, "Entity is NULL");
@@ -1289,8 +1292,7 @@ xmlCtxtDumpEntities(xmlDebugCtxtPtr ctxt, xmlDocPtr doc)
if (!ctxt->check)
fprintf(ctxt->output, "Entities in internal subset\n");
- xmlHashScan(table, (xmlHashScanner) xmlCtxtDumpEntityCallback,
- ctxt);
+ xmlHashScan(table, xmlCtxtDumpEntityCallback, ctxt);
} else
fprintf(ctxt->output, "No entities in internal subset\n");
if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
@@ -1299,8 +1301,7 @@ xmlCtxtDumpEntities(xmlDebugCtxtPtr ctxt, xmlDocPtr doc)
if (!ctxt->check)
fprintf(ctxt->output, "Entities in external subset\n");
- xmlHashScan(table, (xmlHashScanner) xmlCtxtDumpEntityCallback,
- ctxt);
+ xmlHashScan(table, xmlCtxtDumpEntityCallback, ctxt);
} else if (!ctxt->check)
fprintf(ctxt->output, "No entities in external subset\n");
}
diff --git a/doc/symbols.xml b/doc/symbols.xml
index ec275e77..99aea710 100644
--- a/doc/symbols.xml
+++ b/doc/symbols.xml
@@ -1765,4 +1765,7 @@
<symbol file="xpath">xmlXPathNodeEval</symbol>
<symbol file="xpath">xmlXPathSetContextNode</symbol>
</release>
+ <release version="2.9.8">
+ <symbol file="hash">xmlHashDefaultDeallocator</symbol>
+ </release>
</symbols>
diff --git a/entities.c b/entities.c
index c8193376..43549bc5 100644
--- a/entities.c
+++ b/entities.c
@@ -885,10 +885,9 @@ xmlCreateEntitiesTable(void) {
* Deallocate the memory used by an entities in the hash table.
*/
static void
-xmlFreeEntityWrapper(xmlEntityPtr entity,
- const xmlChar *name ATTRIBUTE_UNUSED) {
+xmlFreeEntityWrapper(void *entity, const xmlChar *name ATTRIBUTE_UNUSED) {
if (entity != NULL)
- xmlFreeEntity(entity);
+ xmlFreeEntity((xmlEntityPtr) entity);
}
/**
@@ -899,7 +898,7 @@ xmlFreeEntityWrapper(xmlEntityPtr entity,
*/
void
xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
- xmlHashFree(table, (xmlHashDeallocator) xmlFreeEntityWrapper);
+ xmlHashFree(table, xmlFreeEntityWrapper);
}
#ifdef LIBXML_TREE_ENABLED
@@ -911,8 +910,9 @@ xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
*
* Returns the new xmlEntitiesPtr or NULL in case of error.
*/
-static xmlEntityPtr
-xmlCopyEntity(xmlEntityPtr ent) {
+static void *
+xmlCopyEntity(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlEntityPtr ent = (xmlEntityPtr) payload;
xmlEntityPtr cur;
cur = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
@@ -949,7 +949,7 @@ xmlCopyEntity(xmlEntityPtr ent) {
*/
xmlEntitiesTablePtr
xmlCopyEntitiesTable(xmlEntitiesTablePtr table) {
- return(xmlHashCopy(table, (xmlHashCopier) xmlCopyEntity));
+ return(xmlHashCopy(table, xmlCopyEntity));
}
#endif /* LIBXML_TREE_ENABLED */
@@ -1090,8 +1090,9 @@ xmlDumpEntityDecl(xmlBufferPtr buf, xmlEntityPtr ent) {
* When using the hash table scan function, arguments need to be reversed
*/
static void
-xmlDumpEntityDeclScan(xmlEntityPtr ent, xmlBufferPtr buf) {
- xmlDumpEntityDecl(buf, ent);
+xmlDumpEntityDeclScan(void *ent, void *buf,
+ const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlDumpEntityDecl((xmlBufferPtr) buf, (xmlEntityPtr) ent);
}
/**
@@ -1103,7 +1104,7 @@ xmlDumpEntityDeclScan(xmlEntityPtr ent, xmlBufferPtr buf) {
*/
void
xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) {
- xmlHashScan(table, (xmlHashScanner)xmlDumpEntityDeclScan, buf);
+ xmlHashScan(table, xmlDumpEntityDeclScan, buf);
}
#endif /* LIBXML_OUTPUT_ENABLED */
#define bottom_entities
diff --git a/hash.c b/hash.c
index 5dcaeb40..b0b4abc9 100644
--- a/hash.c
+++ b/hash.c
@@ -361,6 +361,18 @@ xmlHashFree(xmlHashTablePtr table, xmlHashDeallocator f) {
}
/**
+ * xmlHashDefaultDeallocator:
+ * @entry: the hash table entry
+ * @name: the entry's name
+ *
+ * Free a hash table entry with xmlFree.
+ */
+void
+xmlHashDefaultDeallocator(void *entry, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlFree(entry);
+}
+
+/**
* xmlHashAddEntry:
* @table: the hash table
* @name: the name of the userdata
@@ -912,8 +924,11 @@ void
xmlHashScan3(xmlHashTablePtr table, const xmlChar *name,
const xmlChar *name2, const xmlChar *name3,
xmlHashScanner f, void *data) {
- xmlHashScanFull3 (table, name, name2, name3,
- (xmlHashScannerFull) f, data);
+ stubData stubdata;
+ stubdata.data = data;
+ stubdata.hashscanner = f;
+ xmlHashScanFull3(table, name, name2, name3, stubHashScannerFull,
+ &stubdata);
}
/**
diff --git a/include/libxml/hash.h b/include/libxml/hash.h
index dc8ab7ec..6352874e 100644
--- a/include/libxml/hash.h
+++ b/include/libxml/hash.h
@@ -66,7 +66,7 @@ extern "C" {
*
* Callback to free data from a hash.
*/
-typedef void (*xmlHashDeallocator)(void *payload, xmlChar *name);
+typedef void (*xmlHashDeallocator)(void *payload, const xmlChar *name);
/**
* xmlHashCopier:
* @payload: the data in the hash
@@ -76,7 +76,7 @@ typedef void (*xmlHashDeallocator)(void *payload, xmlChar *name);
*
* Returns a copy of the data or NULL in case of error.
*/
-typedef void *(*xmlHashCopier)(void *payload, xmlChar *name);
+typedef void *(*xmlHashCopier)(void *payload, const xmlChar *name);
/**
* xmlHashScanner:
* @payload: the data in the hash
@@ -85,7 +85,7 @@ typedef void *(*xmlHashCopier)(void *payload, xmlChar *name);
*
* Callback when scanning data in a hash with the simple scanner.
*/
-typedef void (*xmlHashScanner)(void *payload, void *data, xmlChar *name);
+typedef void (*xmlHashScanner)(void *payload, void *data, const xmlChar *name);
/**
* xmlHashScannerFull:
* @payload: the data in the hash
@@ -111,6 +111,9 @@ XMLPUBFUN xmlHashTablePtr XMLCALL
XMLPUBFUN void XMLCALL
xmlHashFree (xmlHashTablePtr table,
xmlHashDeallocator f);
+XMLPUBFUN void XMLCALL
+ xmlHashDefaultDeallocator(void *entry,
+ const xmlChar *name);
/*
* Add a new entry to the hash table.
diff --git a/parser.c b/parser.c
index 515ced5f..04aa7171 100644
--- a/parser.c
+++ b/parser.c
@@ -14876,7 +14876,7 @@ xmlCtxtReset(xmlParserCtxtPtr ctxt)
xmlInitNodeInfoSeq(&ctxt->node_seq);
if (ctxt->attsDefault != NULL) {
- xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
+ xmlHashFree(ctxt->attsDefault, xmlHashDefaultDeallocator);
ctxt->attsDefault = NULL;
}
if (ctxt->attsSpecial != NULL) {
diff --git a/parserInternals.c b/parserInternals.c
index efb23872..e75e5473 100644
--- a/parserInternals.c
+++ b/parserInternals.c
@@ -1795,7 +1795,7 @@ xmlFreeParserCtxt(xmlParserCtxtPtr ctxt)
if (ctxt->pushTab != NULL) xmlFree(ctxt->pushTab);
if (ctxt->attallocs != NULL) xmlFree(ctxt->attallocs);
if (ctxt->attsDefault != NULL)
- xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
+ xmlHashFree(ctxt->attsDefault, xmlHashDefaultDeallocator);
if (ctxt->attsSpecial != NULL)
xmlHashFree(ctxt->attsSpecial, NULL);
if (ctxt->freeElems != NULL) {
diff --git a/relaxng.c b/relaxng.c
index b12e1ae3..88d351df 100644
--- a/relaxng.c
+++ b/relaxng.c
@@ -2729,9 +2729,10 @@ static xmlHashTablePtr xmlRelaxNGRegisteredTypes = NULL;
* Free the structure associated to the type library
*/
static void
-xmlRelaxNGFreeTypeLibrary(xmlRelaxNGTypeLibraryPtr lib,
+xmlRelaxNGFreeTypeLibrary(void *payload,
const xmlChar * namespace ATTRIBUTE_UNUSED)
{
+ xmlRelaxNGTypeLibraryPtr lib = (xmlRelaxNGTypeLibraryPtr) payload;
if (lib == NULL)
return;
if (lib->namespace != NULL)
@@ -2842,8 +2843,7 @@ xmlRelaxNGCleanupTypes(void)
xmlSchemaCleanupTypes();
if (xmlRelaxNGTypeInitialized == 0)
return;
- xmlHashFree(xmlRelaxNGRegisteredTypes, (xmlHashDeallocator)
- xmlRelaxNGFreeTypeLibrary);
+ xmlHashFree(xmlRelaxNGRegisteredTypes, xmlRelaxNGFreeTypeLibrary);
xmlRelaxNGTypeInitialized = 0;
}
@@ -4311,10 +4311,11 @@ xmlRelaxNGCheckGroupAttrs(xmlRelaxNGParserCtxtPtr ctxt,
* algorithm
*/
static void
-xmlRelaxNGComputeInterleaves(xmlRelaxNGDefinePtr def,
- xmlRelaxNGParserCtxtPtr ctxt,
- xmlChar * name ATTRIBUTE_UNUSED)
+xmlRelaxNGComputeInterleaves(void *payload, void *data,
+ const xmlChar * name ATTRIBUTE_UNUSED)
{
+ xmlRelaxNGDefinePtr def = (xmlRelaxNGDefinePtr) payload;
+ xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
xmlRelaxNGDefinePtr cur, *tmp;
xmlRelaxNGPartitionPtr partitions = NULL;
@@ -4663,7 +4664,7 @@ xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
* Import import one references into the current grammar
*/
static void
-xmlRelaxNGParseImportRef(void *payload, void *data, xmlChar *name) {
+xmlRelaxNGParseImportRef(void *payload, void *data, const xmlChar *name) {
xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
xmlRelaxNGDefinePtr def = (xmlRelaxNGDefinePtr) payload;
int tmp;
@@ -5670,10 +5671,10 @@ xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
* element of a given grammar using the same name.
*/
static void
-xmlRelaxNGCheckReference(xmlRelaxNGDefinePtr ref,
- xmlRelaxNGParserCtxtPtr ctxt,
- const xmlChar * name)
+xmlRelaxNGCheckReference(void *payload, void *data, const xmlChar * name)
{
+ xmlRelaxNGDefinePtr ref = (xmlRelaxNGDefinePtr) payload;
+ xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
xmlRelaxNGGrammarPtr grammar;
xmlRelaxNGDefinePtr def, cur;
@@ -5726,9 +5727,10 @@ xmlRelaxNGCheckReference(xmlRelaxNGDefinePtr ref,
* element of a given grammar using the same name.
*/
static void
-xmlRelaxNGCheckCombine(xmlRelaxNGDefinePtr define,
- xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * name)
+xmlRelaxNGCheckCombine(void *payload, void *data, const xmlChar * name)
{
+ xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) payload;
+ xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
xmlChar *combine;
int choiceOrInterleave = -1;
int missing = 0;
@@ -6611,16 +6613,14 @@ xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
*/
xmlRelaxNGCombineStart(ctxt, ret);
if (ret->defs != NULL) {
- xmlHashScan(ret->defs, (xmlHashScanner) xmlRelaxNGCheckCombine,
- ctxt);
+ xmlHashScan(ret->defs, xmlRelaxNGCheckCombine, ctxt);
}
/*
* link together defines and refs in this grammar
*/
if (ret->refs != NULL) {
- xmlHashScan(ret->refs, (xmlHashScanner) xmlRelaxNGCheckReference,
- ctxt);
+ xmlHashScan(ret->refs, xmlRelaxNGCheckReference, ctxt);
}
@@ -7551,8 +7551,7 @@ xmlRelaxNGParse(xmlRelaxNGParserCtxtPtr ctxt)
* try to preprocess interleaves
*/
if (ctxt->interleaves != NULL) {
- xmlHashScan(ctxt->interleaves,
- (xmlHashScanner) xmlRelaxNGComputeInterleaves, ctxt);
+ xmlHashScan(ctxt->interleaves, xmlRelaxNGComputeInterleaves, ctxt);
}
/*
diff --git a/valid.c b/valid.c
index a64b96be..92de541c 100644
--- a/valid.c
+++ b/valid.c
@@ -1597,6 +1597,11 @@ xmlAddElementDecl(xmlValidCtxtPtr ctxt,
return(ret);
}
+static void
+xmlFreeElementTableEntry(void *elem, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlFreeElement((xmlElementPtr) elem);
+}
+
/**
* xmlFreeElementTable:
* @table: An element table
@@ -1605,7 +1610,7 @@ xmlAddElementDecl(xmlValidCtxtPtr ctxt,
*/
void
xmlFreeElementTable(xmlElementTablePtr table) {
- xmlHashFree(table, (xmlHashDeallocator) xmlFreeElement);
+ xmlHashFree(table, xmlFreeElementTableEntry);
}
#ifdef LIBXML_TREE_ENABLED
@@ -1617,8 +1622,9 @@ xmlFreeElementTable(xmlElementTablePtr table) {
*
* Returns the new xmlElementPtr or NULL in case of error.
*/
-static xmlElementPtr
-xmlCopyElement(xmlElementPtr elem) {
+static void *
+xmlCopyElement(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlElementPtr elem = (xmlElementPtr) payload;
xmlElementPtr cur;
cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
@@ -1653,8 +1659,7 @@ xmlCopyElement(xmlElementPtr elem) {
*/
xmlElementTablePtr
xmlCopyElementTable(xmlElementTablePtr table) {
- return((xmlElementTablePtr) xmlHashCopy(table,
- (xmlHashCopier) xmlCopyElement));
+ return((xmlElementTablePtr) xmlHashCopy(table, xmlCopyElement));
}
#endif /* LIBXML_TREE_ENABLED */
@@ -1728,8 +1733,9 @@ xmlDumpElementDecl(xmlBufferPtr buf, xmlElementPtr elem) {
* the arguments.
*/
static void
-xmlDumpElementDeclScan(xmlElementPtr elem, xmlBufferPtr buf) {
- xmlDumpElementDecl(buf, elem);
+xmlDumpElementDeclScan(void *elem, void *buf,
+ const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlDumpElementDecl((xmlBufferPtr) buf, (xmlElementPtr) elem);
}
/**
@@ -1743,7 +1749,7 @@ void
xmlDumpElementTable(xmlBufferPtr buf, xmlElementTablePtr table) {
if ((buf == NULL) || (table == NULL))
return;
- xmlHashScan(table, (xmlHashScanner) xmlDumpElementDeclScan, buf);
+ xmlHashScan(table, xmlDumpElementDeclScan, buf);
}
#endif /* LIBXML_OUTPUT_ENABLED */
@@ -2143,6 +2149,11 @@ xmlAddAttributeDecl(xmlValidCtxtPtr ctxt,
return(ret);
}
+static void
+xmlFreeAttributeTableEntry(void *attr, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlFreeAttribute((xmlAttributePtr) attr);
+}
+
/**
* xmlFreeAttributeTable:
* @table: An attribute table
@@ -2151,7 +2162,7 @@ xmlAddAttributeDecl(xmlValidCtxtPtr ctxt,
*/
void
xmlFreeAttributeTable(xmlAttributeTablePtr table) {
- xmlHashFree(table, (xmlHashDeallocator) xmlFreeAttribute);
+ xmlHashFree(table, xmlFreeAttributeTableEntry);
}
#ifdef LIBXML_TREE_ENABLED
@@ -2163,8 +2174,9 @@ xmlFreeAttributeTable(xmlAttributeTablePtr table) {
*
* Returns the new xmlAttributePtr or NULL in case of error.
*/
-static xmlAttributePtr
-xmlCopyAttribute(xmlAttributePtr attr) {
+static void *
+xmlCopyAttribute(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlAttributePtr attr = (xmlAttributePtr) payload;
xmlAttributePtr cur;
cur = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
@@ -2198,8 +2210,7 @@ xmlCopyAttribute(xmlAttributePtr attr) {
*/
xmlAttributeTablePtr
xmlCopyAttributeTable(xmlAttributeTablePtr table) {
- return((xmlAttributeTablePtr) xmlHashCopy(table,
- (xmlHashCopier) xmlCopyAttribute));
+ return((xmlAttributeTablePtr) xmlHashCopy(table, xmlCopyAttribute));
}
#endif /* LIBXML_TREE_ENABLED */
@@ -2294,8 +2305,9 @@ xmlDumpAttributeDecl(xmlBufferPtr buf, xmlAttributePtr attr) {
* This is used with the hash scan function - just reverses arguments
*/
static void
-xmlDumpAttributeDeclScan(xmlAttributePtr attr, xmlBufferPtr buf) {
- xmlDumpAttributeDecl(buf, attr);
+xmlDumpAttributeDeclScan(void *attr, void *buf,
+ const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlDumpAttributeDecl((xmlBufferPtr) buf, (xmlAttributePtr) attr);
}
/**
@@ -2309,7 +2321,7 @@ void
xmlDumpAttributeTable(xmlBufferPtr buf, xmlAttributeTablePtr table) {
if ((buf == NULL) || (table == NULL))
return;
- xmlHashScan(table, (xmlHashScanner) xmlDumpAttributeDeclScan, buf);
+ xmlHashScan(table, xmlDumpAttributeDeclScan, buf);
}
#endif /* LIBXML_OUTPUT_ENABLED */
@@ -2415,6 +2427,11 @@ xmlAddNotationDecl(xmlValidCtxtPtr ctxt, xmlDtdPtr dtd,
return(ret);
}
+static void
+xmlFreeNotationTableEntry(void *nota, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlFreeNotation((xmlNotationPtr) nota);
+}
+
/**
* xmlFreeNotationTable:
* @table: An notation table
@@ -2423,7 +2440,7 @@ xmlAddNotationDecl(xmlValidCtxtPtr ctxt, xmlDtdPtr dtd,
*/
void
xmlFreeNotationTable(xmlNotationTablePtr table) {
- xmlHashFree(table, (xmlHashDeallocator) xmlFreeNotation);
+ xmlHashFree(table, xmlFreeNotationTableEntry);
}
#ifdef LIBXML_TREE_ENABLED
@@ -2435,8 +2452,9 @@ xmlFreeNotationTable(xmlNotationTablePtr table) {
*
* Returns the new xmlNotationPtr or NULL in case of error.
*/
-static xmlNotationPtr
-xmlCopyNotation(xmlNotationPtr nota) {
+static void *
+xmlCopyNotation(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlNotationPtr nota = (xmlNotationPtr) payload;
xmlNotationPtr cur;
cur = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
@@ -2469,8 +2487,7 @@ xmlCopyNotation(xmlNotationPtr nota) {
*/
xmlNotationTablePtr
xmlCopyNotationTable(xmlNotationTablePtr table) {
- return((xmlNotationTablePtr) xmlHashCopy(table,
- (xmlHashCopier) xmlCopyNotation));
+ return((xmlNotationTablePtr) xmlHashCopy(table, xmlCopyNotation));
}
#endif /* LIBXML_TREE_ENABLED */
@@ -2510,8 +2527,9 @@ xmlDumpNotationDecl(xmlBufferPtr buf, xmlNotationPtr nota) {
* This is called with the hash scan function, and just reverses args
*/
static void
-xmlDumpNotationDeclScan(xmlNotationPtr nota, xmlBufferPtr buf) {
- xmlDumpNotationDecl(buf, nota);
+xmlDumpNotationDeclScan(void *nota, void *buf,
+ const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlDumpNotationDecl((xmlBufferPtr) buf, (xmlNotationPtr) nota);
}
/**
@@ -2525,7 +2543,7 @@ void
xmlDumpNotationTable(xmlBufferPtr buf, xmlNotationTablePtr table) {
if ((buf == NULL) || (table == NULL))
return;
- xmlHashScan(table, (xmlHashScanner) xmlDumpNotationDeclScan, buf);
+ xmlHashScan(table, xmlDumpNotationDeclScan, buf);
}
#endif /* LIBXML_OUTPUT_ENABLED */
@@ -2653,6 +2671,11 @@ xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
return(ret);
}
+static void
+xmlFreeIDTableEntry(void *id, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlFreeID((xmlIDPtr) id);
+}
+
/**
* xmlFreeIDTable:
* @table: An id table
@@ -2661,7 +2684,7 @@ xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
*/
void
xmlFreeIDTable(xmlIDTablePtr table) {
- xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
+ xmlHashFree(table, xmlFreeIDTableEntry);
}
/**
@@ -2761,7 +2784,7 @@ xmlRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
return(-1);
}
- xmlHashRemoveEntry(table, ID, (xmlHashDeallocator) xmlFreeID);
+ xmlHashRemoveEntry(table, ID, xmlFreeIDTableEntry);
xmlFree(ID);
attr->atype = 0;
return(0);
@@ -2845,13 +2868,14 @@ xmlFreeRef(xmlLinkPtr lk) {
}
/**
- * xmlFreeRefList:
+ * xmlFreeRefTableEntry:
* @list_ref: A list of references.
*
* Deallocate the memory used by a list of references
*/
static void
-xmlFreeRefList(xmlListPtr list_ref) {
+xmlFreeRefTableEntry(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlListPtr list_ref = (xmlListPtr) payload;
if (list_ref == NULL) return;
xmlListDelete(list_ref);
}
@@ -3002,7 +3026,7 @@ failed:
*/
void
xmlFreeRefTable(xmlRefTablePtr table) {
- xmlHashFree(table, (xmlHashDeallocator) xmlFreeRefList);
+ xmlHashFree(table, xmlFreeRefTableEntry);
}
/**
@@ -3099,8 +3123,7 @@ xmlRemoveRef(xmlDocPtr doc, xmlAttrPtr attr) {
/*If the list is empty then remove the list entry in the hash */
if (xmlListEmpty(ref_list))
- xmlHashUpdateEntry(table, ID, NULL, (xmlHashDeallocator)
- xmlFreeRefList);
+ xmlHashUpdateEntry(table, ID, NULL, xmlFreeRefTableEntry);
xmlFree(ID);
return(0);
}
@@ -4096,8 +4119,10 @@ xmlValidNormalizeAttributeValue(xmlDocPtr doc, xmlNodePtr elem,
}
static void
-xmlValidateAttributeIdCallback(xmlAttributePtr attr, int *count,
- const xmlChar* name ATTRIBUTE_UNUSED) {
+xmlValidateAttributeIdCallback(void *payload, void *data,
+ const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlAttributePtr attr = (xmlAttributePtr) payload;
+ int *count = (int *) data;
if (attr->atype == XML_ATTRIBUTE_ID) (*count)++;
}
@@ -4169,7 +4194,7 @@ xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
nbId = 0;
if (doc->intSubset != NULL) {
table = (xmlAttributeTablePtr) doc->intSubset->attributes;
- xmlHashScan3(table, NULL, NULL, attr->elem, (xmlHashScanner)
+ xmlHashScan3(table, NULL, NULL, attr->elem,
xmlValidateAttributeIdCallback, &nbId);
}
}
@@ -6545,8 +6570,9 @@ xmlWalkValidateList(const void *data, const void *user)
*
*/
static void
-xmlValidateCheckRefCallback(xmlListPtr ref_list, xmlValidCtxtPtr ctxt,
- const xmlChar *name) {
+xmlValidateCheckRefCallback(void *payload, void *data, const xmlChar *name) {
+ xmlListPtr ref_list = (xmlListPtr) payload;
+ xmlValidCtxtPtr ctxt = (xmlValidCtxtPtr) data;
xmlValidateMemo memo;
if (ref_list == NULL)
@@ -6602,7 +6628,7 @@ xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
table = (xmlRefTablePtr) doc->refs;
ctxt->doc = doc;
ctxt->valid = 1;
- xmlHashScan(table, (xmlHashScanner) xmlValidateCheckRefCallback, ctxt);
+ xmlHashScan(table, xmlValidateCheckRefCallback, ctxt);
ctxt->finishDtd = save;
return(ctxt->valid);
@@ -6659,8 +6685,10 @@ xmlValidateDtd(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlDtdPtr dtd) {
}
static void
-xmlValidateNotationCallback(xmlEntityPtr cur, xmlValidCtxtPtr ctxt,
+xmlValidateNotationCallback(void *payload, void *data,
const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlEntityPtr cur = (xmlEntityPtr) payload;
+ xmlValidCtxtPtr ctxt = (xmlValidCtxtPtr) data;
if (cur == NULL)
return;
if (cur->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
@@ -6678,8 +6706,10 @@ xmlValidateNotationCallback(xmlEntityPtr cur, xmlValidCtxtPtr ctxt,
}
static void
-xmlValidateAttributeCallback(xmlAttributePtr cur, xmlValidCtxtPtr ctxt,
- const xmlChar *name ATTRIBUTE_UNUSED) {
+xmlValidateAttributeCallback(void *payload, void *data,
+ const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlAttributePtr cur = (xmlAttributePtr) payload;
+ xmlValidCtxtPtr ctxt = (xmlValidCtxtPtr) data;
int ret;
xmlDocPtr doc;
xmlElementPtr elem = NULL;
@@ -6778,22 +6808,20 @@ xmlValidateDtdFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
dtd = doc->intSubset;
if ((dtd != NULL) && (dtd->attributes != NULL)) {
table = (xmlAttributeTablePtr) dtd->attributes;
- xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
+ xmlHashScan(table, xmlValidateAttributeCallback, ctxt);
}
if ((dtd != NULL) && (dtd->entities != NULL)) {
entities = (xmlEntitiesTablePtr) dtd->entities;
- xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
- ctxt);
+ xmlHashScan(entities, xmlValidateNotationCallback, ctxt);
}
dtd = doc->extSubset;
if ((dtd != NULL) && (dtd->attributes != NULL)) {
table = (xmlAttributeTablePtr) dtd->attributes;
- xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
+ xmlHashScan(table, xmlValidateAttributeCallback, ctxt);
}
if ((dtd != NULL) && (dtd->entities != NULL)) {
entities = (xmlEntitiesTablePtr) dtd->entities;
- xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
- ctxt);
+ xmlHashScan(entities, xmlValidateNotationCallback, ctxt);
}
return(ctxt->valid);
}
diff --git a/xinclude.c b/xinclude.c
index e3bb43ec..001e992f 100644
--- a/xinclude.c
+++ b/xinclude.c
@@ -1261,8 +1261,10 @@ struct _xmlXIncludeMergeData {
* Inplements the merge of one entity
*/
static void
-xmlXIncludeMergeEntity(xmlEntityPtr ent, xmlXIncludeMergeDataPtr data,
- xmlChar *name ATTRIBUTE_UNUSED) {
+xmlXIncludeMergeEntity(void *payload, void *vdata,
+ const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlEntityPtr ent = (xmlEntityPtr) payload;
+ xmlXIncludeMergeDataPtr data = (xmlXIncludeMergeDataPtr) vdata;
xmlEntityPtr ret, prev;
xmlDocPtr doc;
xmlXIncludeCtxtPtr ctxt;
@@ -1367,7 +1369,7 @@ xmlXIncludeMergeEntities(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
data.doc = doc;
xmlHashScan((xmlHashTablePtr) source->entities,
- (xmlHashScanner) xmlXIncludeMergeEntity, &data);
+ xmlXIncludeMergeEntity, &data);
}
source = from->extSubset;
if ((source != NULL) && (source->entities != NULL)) {
@@ -1382,7 +1384,7 @@ xmlXIncludeMergeEntities(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc,
if ((!xmlStrEqual(target->ExternalID, source->ExternalID)) &&
(!xmlStrEqual(target->SystemID, source->SystemID))) {
xmlHashScan((xmlHashTablePtr) source->entities,
- (xmlHashScanner) xmlXIncludeMergeEntity, &data);
+ xmlXIncludeMergeEntity, &data);
}
}
return(0);
diff --git a/xmlreader.c b/xmlreader.c
index 34c4c6bc..4053269b 100644
--- a/xmlreader.c
+++ b/xmlreader.c
@@ -491,6 +491,11 @@ xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur) {
}
}
+static void
+xmlTextReaderFreeIDTableEntry(void *id, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlFreeID((xmlIDPtr) id);
+}
+
/**
* xmlTextReaderFreeIDTable:
* @table: An id table
@@ -499,7 +504,7 @@ xmlTextReaderFreeNode(xmlTextReaderPtr reader, xmlNodePtr cur) {
*/
static void
xmlTextReaderFreeIDTable(xmlIDTablePtr table) {
- xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
+ xmlHashFree(table, xmlTextReaderFreeIDTableEntry);
}
/**
diff --git a/xmlschemas.c b/xmlschemas.c
index 05a12e0b..f1274604 100644
--- a/xmlschemas.c
+++ b/xmlschemas.c
@@ -3565,6 +3565,12 @@ xmlSchemaBucketFree(xmlSchemaBucketPtr bucket)
xmlFree(bucket);
}
+static void
+xmlSchemaBucketFreeEntry(void *bucket, const xmlChar *name ATTRIBUTE_UNUSED)
+{
+ xmlSchemaBucketFree((xmlSchemaBucketPtr) bucket);
+}
+
static xmlSchemaBucketPtr
xmlSchemaBucketCreate(xmlSchemaParserCtxtPtr pctxt,
int type, const xmlChar *targetNamespace)
@@ -4159,8 +4165,7 @@ xmlSchemaFree(xmlSchemaPtr schema)
xmlHashFree(schema->idcDef, NULL);
if (schema->schemasImports != NULL)
- xmlHashFree(schema->schemasImports,
- (xmlHashDeallocator) xmlSchemaBucketFree);
+ xmlHashFree(schema->schemasImports, xmlSchemaBucketFreeEntry);
if (schema->includes != NULL) {
xmlSchemaItemListPtr list = (xmlSchemaItemListPtr) schema->includes;
int i;
@@ -4196,11 +4201,13 @@ xmlSchemaTypeDump(xmlSchemaTypePtr type, FILE * output); /* forward */
* Dump the element
*/
static void
-xmlSchemaElementDump(xmlSchemaElementPtr elem, FILE * output,
+xmlSchemaElementDump(void *payload, void *data,
const xmlChar * name ATTRIBUTE_UNUSED,
const xmlChar * namespace ATTRIBUTE_UNUSED,
const xmlChar * context ATTRIBUTE_UNUSED)
{
+ xmlSchemaElementPtr elem = (xmlSchemaElementPtr) payload;
+ FILE *output = (FILE *) data;
if (elem == NULL)
return;
@@ -4515,6 +4522,13 @@ xmlSchemaTypeDump(xmlSchemaTypePtr type, FILE * output)
#endif
}
+static void
+xmlSchemaTypeDumpEntry(void *type, void *output,
+ const xmlChar *name ATTRIBUTE_UNUSED)
+{
+ xmlSchemaTypeDump((xmlSchemaTypePtr) type, (FILE *) output);
+}
+
/**
* xmlSchemaDump:
* @output: the file output
@@ -4543,10 +4557,8 @@ xmlSchemaDump(FILE * output, xmlSchemaPtr schema)
fprintf(output, "\n");
if (schema->annot != NULL)
xmlSchemaAnnotDump(output, schema->annot);
- xmlHashScan(schema->typeDecl, (xmlHashScanner) xmlSchemaTypeDump,
- output);
- xmlHashScanFull(schema->elemDecl,
- (xmlHashScannerFull) xmlSchemaElementDump, output);
+ xmlHashScan(schema->typeDecl, xmlSchemaTypeDumpEntry, output);
+ xmlHashScanFull(schema->elemDecl, xmlSchemaElementDump, output);
}
#ifdef DEBUG_IDC_NODE_TABLE
@@ -5706,6 +5718,12 @@ xmlSchemaSubstGroupFree(xmlSchemaSubstGroupPtr group)
xmlFree(group);
}
+static void
+xmlSchemaSubstGroupFreeEntry(void *group, const xmlChar *name ATTRIBUTE_UNUSED)
+{
+ xmlSchemaSubstGroupFree((xmlSchemaSubstGroupPtr) group);
+}
+
static xmlSchemaSubstGroupPtr
xmlSchemaSubstGroupAdd(xmlSchemaParserCtxtPtr pctxt,
xmlSchemaElementPtr head)
@@ -9918,8 +9936,7 @@ xmlSchemaConstructionCtxtFree(xmlSchemaConstructionCtxtPtr con)
if (con->pending != NULL)
xmlSchemaItemListFree(con->pending);
if (con->substGroups != NULL)
- xmlHashFree(con->substGroups,
- (xmlHashDeallocator) xmlSchemaSubstGroupFree);
+ xmlHashFree(con->substGroups, xmlSchemaSubstGroupFreeEntry);
if (con->redefs != NULL)
xmlSchemaRedefListFree(con->redefs);
if (con->dict != NULL)
@@ -21293,8 +21310,7 @@ exit:
con->bucket = oldbucket;
con->pending->nbItems = 0;
if (con->substGroups != NULL) {
- xmlHashFree(con->substGroups,
- (xmlHashDeallocator) xmlSchemaSubstGroupFree);
+ xmlHashFree(con->substGroups, xmlSchemaSubstGroupFreeEntry);
con->substGroups = NULL;
}
if (con->redefs != NULL) {
@@ -22002,9 +22018,11 @@ xmlSchemaVAddNodeQName(xmlSchemaValidCtxtPtr vctxt,
* Returns the item, or NULL on internal errors.
*/
static void
-xmlSchemaAugmentIDC(xmlSchemaIDCPtr idcDef,
- xmlSchemaValidCtxtPtr vctxt)
+xmlSchemaAugmentIDC(void *payload, void *data,
+ const xmlChar *name ATTRIBUTE_UNUSED)
{
+ xmlSchemaIDCPtr idcDef = (xmlSchemaIDCPtr) payload;
+ xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) data;
xmlSchemaIDCAugPtr aidc;
aidc = (xmlSchemaIDCAugPtr) xmlMalloc(sizeof(xmlSchemaIDCAug));
@@ -22038,10 +22056,12 @@ xmlSchemaAugmentIDC(xmlSchemaIDCPtr idcDef,
* Creates an augmented IDC definition for the imported schema.
*/
static void
-xmlSchemaAugmentImportedIDC(xmlSchemaImportPtr imported, xmlSchemaValidCtxtPtr vctxt, xmlChar *name ATTRIBUTE_UNUSED) {
+xmlSchemaAugmentImportedIDC(void *payload, void *data,
+ const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlSchemaImportPtr imported = (xmlSchemaImportPtr) payload;
+ xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) data;
if (imported->schema->idcDef != NULL) {
- xmlHashScan(imported->schema->idcDef ,
- (xmlHashScanner) xmlSchemaAugmentIDC, vctxt);
+ xmlHashScan(imported->schema->idcDef, xmlSchemaAugmentIDC, vctxt);
}
}
@@ -26885,7 +26905,8 @@ xmlSchemaValidateElem(xmlSchemaValidCtxtPtr vctxt)
* Augment the IDC definitions for the main schema and all imported ones
* NOTE: main schema is the first in the imported list
*/
- xmlHashScan(vctxt->schema->schemasImports,(xmlHashScanner)xmlSchemaAugmentImportedIDC, vctxt);
+ xmlHashScan(vctxt->schema->schemasImports, xmlSchemaAugmentImportedIDC,
+ vctxt);
}
if (vctxt->depth > 0) {
/*
@@ -28127,7 +28148,8 @@ xmlSchemaPreRun(xmlSchemaValidCtxtPtr vctxt) {
* Augment the IDC definitions for the main schema and all imported ones
* NOTE: main schema if the first in the imported list
*/
- xmlHashScan(vctxt->schema->schemasImports,(xmlHashScanner)xmlSchemaAugmentImportedIDC, vctxt);
+ xmlHashScan(vctxt->schema->schemasImports, xmlSchemaAugmentImportedIDC,
+ vctxt);
return(0);
}
diff --git a/xmlschemastypes.c b/xmlschemastypes.c
index c6c93659..ca381d38 100644
--- a/xmlschemastypes.c
+++ b/xmlschemastypes.c
@@ -619,6 +619,11 @@ xmlSchemaInitTypes(void)
xmlSchemaTypesInitialized = 1;
}
+static void
+xmlSchemaFreeTypeEntry(void *type, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlSchemaFreeType((xmlSchemaTypePtr) type);
+}
+
/**
* xmlSchemaCleanupTypes:
*
@@ -646,7 +651,7 @@ xmlSchemaCleanupTypes(void) {
xmlFree((xmlSchemaParticlePtr) particle);
xmlSchemaTypeAnyTypeDef->subtypes = NULL;
}
- xmlHashFree(xmlSchemaTypesBank, (xmlHashDeallocator) xmlSchemaFreeType);
+ xmlHashFree(xmlSchemaTypesBank, xmlSchemaFreeTypeEntry);
xmlSchemaTypesInitialized = 0;
}
diff --git a/xpath.c b/xpath.c
index 35274731..0dc5e34a 100644
--- a/xpath.c
+++ b/xpath.c
@@ -978,6 +978,8 @@ static int
xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
xmlXPathStepOpPtr op,
int isPredicate);
+static void
+xmlXPathFreeObjectEntry(void *obj, const xmlChar *name);
/************************************************************************
* *
@@ -4582,7 +4584,7 @@ xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
xmlFree(strval);
}
}
- xmlHashFree(hash, (xmlHashDeallocator) xmlFree);
+ xmlHashFree(hash, xmlHashDefaultDeallocator);
return(ret);
}
@@ -5044,10 +5046,9 @@ xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
return(-1);
if (value == NULL)
return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri,
- (xmlHashDeallocator)xmlXPathFreeObject));
+ xmlXPathFreeObjectEntry));
return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
- (void *) value,
- (xmlHashDeallocator)xmlXPathFreeObject));
+ (void *) value, xmlXPathFreeObjectEntry));
}
/**
@@ -5137,7 +5138,7 @@ xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
if (ctxt == NULL)
return;
- xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject);
+ xmlHashFree(ctxt->varHash, xmlXPathFreeObjectEntry);
ctxt->varHash = NULL;
}
@@ -5168,9 +5169,9 @@ xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
return(-1);
if (ns_uri == NULL)
return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
- (xmlHashDeallocator)xmlFree));
+ xmlHashDefaultDeallocator));
return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri),
- (xmlHashDeallocator)xmlFree));
+ xmlHashDefaultDeallocator));
}
/**
@@ -5219,7 +5220,7 @@ xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
if (ctxt == NULL)
return;
- xmlHashFree(ctxt->nsHash, (xmlHashDeallocator)xmlFree);
+ xmlHashFree(ctxt->nsHash, xmlHashDefaultDeallocator);
ctxt->nsHash = NULL;
}
@@ -5533,6 +5534,11 @@ xmlXPathFreeObject(xmlXPathObjectPtr obj) {
xmlFree(obj);
}
+static void
+xmlXPathFreeObjectEntry(void *obj, const xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlXPathFreeObject((xmlXPathObjectPtr) obj);
+}
+
/**
* xmlXPathReleaseObject:
* @obj: the xmlXPathObjectPtr to free or to cache
View Lorry Controller Status