XML/valid.c - diff

Return to valid.c CVS log

Up to [Public] / XML

Diff for /XML/valid.c between versions 1.25 and 1.26

version 1.25, 1999/08/30 11:19:42	version 1.26, 1999/09/02 16:30:54
Line 10	Line 10
#include <stdio.h>	#include <stdio.h>
#include <stdlib.h>	#include <stdlib.h>
#include <string.h>	#include <string.h>
	#include "xmlmemory.h"
#include "valid.h"	#include "valid.h"
#include "parser.h"	#include "parser.h"
#include "parserInternals.h"	#include "parserInternals.h"
Line 63 xmlNewElementContent(CHAR *name, xmlElem	Line 64 xmlNewElementContent(CHAR *name, xmlElem
fprintf(stderr, "xmlNewElementContent: unknown type %d\n", type);	fprintf(stderr, "xmlNewElementContent: unknown type %d\n", type);
exit(1);	exit(1);
}	}
ret = (xmlElementContentPtr) malloc(sizeof(xmlElementContent));	ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlNewElementContent : out of memory!\n");	fprintf(stderr, "xmlNewElementContent : out of memory!\n");
return(NULL);	return(NULL);
Line 113 xmlFreeElementContent(xmlElementContentP	Line 114 xmlFreeElementContent(xmlElementContentP
if (cur == NULL) return;	if (cur == NULL) return;
if (cur->c1 != NULL) xmlFreeElementContent(cur->c1);	if (cur->c1 != NULL) xmlFreeElementContent(cur->c1);
if (cur->c2 != NULL) xmlFreeElementContent(cur->c2);	if (cur->c2 != NULL) xmlFreeElementContent(cur->c2);
if (cur->name != NULL) free((CHAR *) cur->name);	if (cur->name != NULL) xmlFree((CHAR *) cur->name);
memset(cur, -1, sizeof(xmlElementContent));	memset(cur, -1, sizeof(xmlElementContent));
free(cur);	xmlFree(cur);
}	}

/**	/**
Line 263 xmlCreateElementTable(void) {	Line 264 xmlCreateElementTable(void) {
xmlElementTablePtr ret;	xmlElementTablePtr ret;

ret = (xmlElementTablePtr)	ret = (xmlElementTablePtr)
malloc(sizeof(xmlElementTable));	xmlMalloc(sizeof(xmlElementTable));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCreateElementTable : malloc(%ld) failed\n",	fprintf(stderr, "xmlCreateElementTable : xmlMalloc(%ld) failed\n",
(long)sizeof(xmlElementTable));	(long)sizeof(xmlElementTable));
return(NULL);	return(NULL);
}	}
ret->max_elements = XML_MIN_ELEMENT_TABLE;	ret->max_elements = XML_MIN_ELEMENT_TABLE;
ret->nb_elements = 0;	ret->nb_elements = 0;
ret->table = (xmlElementPtr *)	ret->table = (xmlElementPtr *)
malloc(ret->max_elements * sizeof(xmlElementPtr));	xmlMalloc(ret->max_elements * sizeof(xmlElementPtr));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCreateElementTable : malloc(%ld) failed\n",	fprintf(stderr, "xmlCreateElementTable : xmlMalloc(%ld) failed\n",
ret->max_elements * (long)sizeof(xmlElement));	ret->max_elements * (long)sizeof(xmlElement));
free(ret);	xmlFree(ret);
return(NULL);	return(NULL);
}	}
return(ret);	return(ret);
Line 378 xmlAddElementDecl(xmlValidCtxtPtr ctxt,	Line 379 xmlAddElementDecl(xmlValidCtxtPtr ctxt,
*/	*/
table->max_elements *= 2;	table->max_elements *= 2;
table->table = (xmlElementPtr *)	table->table = (xmlElementPtr *)
realloc(table->table, table->max_elements * sizeof(xmlElementPtr));	xmlRealloc(table->table, table->max_elements * sizeof(xmlElementPtr));
if (table->table == NULL) {	if (table->table == NULL) {
fprintf(stderr, "xmlAddElementDecl: out of memory\n");	fprintf(stderr, "xmlAddElementDecl: out of memory\n");
return(NULL);	return(NULL);
}	}
}	}
ret = (xmlElementPtr) malloc(sizeof(xmlElement));	ret = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlAddElementDecl: out of memory\n");	fprintf(stderr, "xmlAddElementDecl: out of memory\n");
return(NULL);	return(NULL);
Line 414 xmlFreeElement(xmlElementPtr elem) {	Line 415 xmlFreeElement(xmlElementPtr elem) {
if (elem == NULL) return;	if (elem == NULL) return;
xmlFreeElementContent(elem->content);	xmlFreeElementContent(elem->content);
if (elem->name != NULL)	if (elem->name != NULL)
free((CHAR *) elem->name);	xmlFree((CHAR *) elem->name);
memset(elem, -1, sizeof(xmlElement));	memset(elem, -1, sizeof(xmlElement));
free(elem);	xmlFree(elem);
}	}

/**	/**
Line 434 xmlFreeElementTable(xmlElementTablePtr t	Line 435 xmlFreeElementTable(xmlElementTablePtr t
for (i = 0;i < table->nb_elements;i++) {	for (i = 0;i < table->nb_elements;i++) {
xmlFreeElement(table->table[i]);	xmlFreeElement(table->table[i]);
}	}
free(table->table);	xmlFree(table->table);
free(table);	xmlFree(table);
}	}

/**	/**
Line 452 xmlCopyElementTable(xmlElementTablePtr t	Line 453 xmlCopyElementTable(xmlElementTablePtr t
xmlElementPtr cur, ent;	xmlElementPtr cur, ent;
int i;	int i;

ret = (xmlElementTablePtr) malloc(sizeof(xmlElementTable));	ret = (xmlElementTablePtr) xmlMalloc(sizeof(xmlElementTable));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCopyElementTable: out of memory !\n");	fprintf(stderr, "xmlCopyElementTable: out of memory !\n");
return(NULL);	return(NULL);
}	}
ret->table = (xmlElementPtr ) malloc(table->max_elements	ret->table = (xmlElementPtr ) xmlMalloc(table->max_elements
sizeof(xmlElementPtr));	sizeof(xmlElementPtr));
if (ret->table == NULL) {	if (ret->table == NULL) {
fprintf(stderr, "xmlCopyElementTable: out of memory !\n");	fprintf(stderr, "xmlCopyElementTable: out of memory !\n");
free(ret);	xmlFree(ret);
return(NULL);	return(NULL);
}	}
ret->max_elements = table->max_elements;	ret->max_elements = table->max_elements;
ret->nb_elements = table->nb_elements;	ret->nb_elements = table->nb_elements;
for (i = 0;i < ret->nb_elements;i++) {	for (i = 0;i < ret->nb_elements;i++) {
cur = (xmlElementPtr) malloc(sizeof(xmlElement));	cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
if (cur == NULL) {	if (cur == NULL) {
fprintf(stderr, "xmlCopyElementTable: out of memory !\n");	fprintf(stderr, "xmlCopyElementTable: out of memory !\n");
free(ret);	xmlFree(ret);
free(ret->table);	xmlFree(ret->table);
return(NULL);	return(NULL);
}	}
ret->table[i] = cur;	ret->table[i] = cur;
Line 549 xmlEnumerationPtr	Line 550 xmlEnumerationPtr
xmlCreateEnumeration(CHAR *name) {	xmlCreateEnumeration(CHAR *name) {
xmlEnumerationPtr ret;	xmlEnumerationPtr ret;

ret = (xmlEnumerationPtr) malloc(sizeof(xmlEnumeration));	ret = (xmlEnumerationPtr) xmlMalloc(sizeof(xmlEnumeration));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCreateEnumeration : malloc(%ld) failed\n",	fprintf(stderr, "xmlCreateEnumeration : xmlMalloc(%ld) failed\n",
(long)sizeof(xmlEnumeration));	(long)sizeof(xmlEnumeration));
return(NULL);	return(NULL);
}	}
Line 576 xmlFreeEnumeration(xmlEnumerationPtr cur	Line 577 xmlFreeEnumeration(xmlEnumerationPtr cur

if (cur->next != NULL) xmlFreeEnumeration(cur->next);	if (cur->next != NULL) xmlFreeEnumeration(cur->next);

if (cur->name != NULL) free((CHAR *) cur->name);	if (cur->name != NULL) xmlFree((CHAR *) cur->name);
memset(cur, -1, sizeof(xmlEnumeration));	memset(cur, -1, sizeof(xmlEnumeration));
free(cur);	xmlFree(cur);
}	}

/**	/**
Line 636 xmlCreateAttributeTable(void) {	Line 637 xmlCreateAttributeTable(void) {
xmlAttributeTablePtr ret;	xmlAttributeTablePtr ret;

ret = (xmlAttributeTablePtr)	ret = (xmlAttributeTablePtr)
malloc(sizeof(xmlAttributeTable));	xmlMalloc(sizeof(xmlAttributeTable));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCreateAttributeTable : malloc(%ld) failed\n",	fprintf(stderr, "xmlCreateAttributeTable : xmlMalloc(%ld) failed\n",
(long)sizeof(xmlAttributeTable));	(long)sizeof(xmlAttributeTable));
return(NULL);	return(NULL);
}	}
ret->max_attributes = XML_MIN_ATTRIBUTE_TABLE;	ret->max_attributes = XML_MIN_ATTRIBUTE_TABLE;
ret->nb_attributes = 0;	ret->nb_attributes = 0;
ret->table = (xmlAttributePtr *)	ret->table = (xmlAttributePtr *)
malloc(ret->max_attributes * sizeof(xmlAttributePtr));	xmlMalloc(ret->max_attributes * sizeof(xmlAttributePtr));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCreateAttributeTable : malloc(%ld) failed\n",	fprintf(stderr, "xmlCreateAttributeTable : xmlMalloc(%ld) failed\n",
ret->max_attributes * (long)sizeof(xmlAttributePtr));	ret->max_attributes * (long)sizeof(xmlAttributePtr));
free(ret);	xmlFree(ret);
return(NULL);	return(NULL);
}	}
return(ret);	return(ret);
Line 831 xmlAddAttributeDecl(xmlValidCtxtPtr ctxt	Line 832 xmlAddAttributeDecl(xmlValidCtxtPtr ctxt
*/	*/
table->max_attributes *= 2;	table->max_attributes *= 2;
table->table = (xmlAttributePtr *)	table->table = (xmlAttributePtr *)
realloc(table->table, table->max_attributes *	xmlRealloc(table->table, table->max_attributes *
sizeof(xmlAttributePtr));	sizeof(xmlAttributePtr));
if (table->table == NULL) {	if (table->table == NULL) {
fprintf(stderr, "xmlAddAttributeDecl: out of memory\n");	fprintf(stderr, "xmlAddAttributeDecl: out of memory\n");
return(NULL);	return(NULL);
}	}
}	}
ret = (xmlAttributePtr) malloc(sizeof(xmlAttribute));	ret = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlAddAttributeDecl: out of memory\n");	fprintf(stderr, "xmlAddAttributeDecl: out of memory\n");
return(NULL);	return(NULL);
Line 884 xmlFreeAttribute(xmlAttributePtr attr) {	Line 885 xmlFreeAttribute(xmlAttributePtr attr) {
if (attr->tree != NULL)	if (attr->tree != NULL)
xmlFreeEnumeration(attr->tree);	xmlFreeEnumeration(attr->tree);
if (attr->elem != NULL)	if (attr->elem != NULL)
free((CHAR *) attr->elem);	xmlFree((CHAR *) attr->elem);
if (attr->name != NULL)	if (attr->name != NULL)
free((CHAR *) attr->name);	xmlFree((CHAR *) attr->name);
if (attr->defaultValue != NULL)	if (attr->defaultValue != NULL)
free((CHAR *) attr->defaultValue);	xmlFree((CHAR *) attr->defaultValue);
memset(attr, -1, sizeof(xmlAttribute));	memset(attr, -1, sizeof(xmlAttribute));
free(attr);	xmlFree(attr);
}	}

/**	/**
Line 908 xmlFreeAttributeTable(xmlAttributeTableP	Line 909 xmlFreeAttributeTable(xmlAttributeTableP
for (i = 0;i < table->nb_attributes;i++) {	for (i = 0;i < table->nb_attributes;i++) {
xmlFreeAttribute(table->table[i]);	xmlFreeAttribute(table->table[i]);
}	}
free(table->table);	xmlFree(table->table);
free(table);	xmlFree(table);
}	}

/**	/**
Line 926 xmlCopyAttributeTable(xmlAttributeTableP	Line 927 xmlCopyAttributeTable(xmlAttributeTableP
xmlAttributePtr cur, attr;	xmlAttributePtr cur, attr;
int i;	int i;

ret = (xmlAttributeTablePtr) malloc(sizeof(xmlAttributeTable));	ret = (xmlAttributeTablePtr) xmlMalloc(sizeof(xmlAttributeTable));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCopyAttributeTable: out of memory !\n");	fprintf(stderr, "xmlCopyAttributeTable: out of memory !\n");
return(NULL);	return(NULL);
}	}
ret->table = (xmlAttributePtr ) malloc(table->max_attributes	ret->table = (xmlAttributePtr ) xmlMalloc(table->max_attributes
sizeof(xmlAttributePtr));	sizeof(xmlAttributePtr));
if (ret->table == NULL) {	if (ret->table == NULL) {
fprintf(stderr, "xmlCopyAttributeTable: out of memory !\n");	fprintf(stderr, "xmlCopyAttributeTable: out of memory !\n");
free(ret);	xmlFree(ret);
return(NULL);	return(NULL);
}	}
ret->max_attributes = table->max_attributes;	ret->max_attributes = table->max_attributes;
ret->nb_attributes = table->nb_attributes;	ret->nb_attributes = table->nb_attributes;
for (i = 0;i < ret->nb_attributes;i++) {	for (i = 0;i < ret->nb_attributes;i++) {
attr = table->table[i];	attr = table->table[i];
cur = (xmlAttributePtr) malloc(sizeof(xmlAttribute));	cur = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
if (cur == NULL) {	if (cur == NULL) {
fprintf(stderr, "xmlCopyAttributeTable: out of memory !\n");	fprintf(stderr, "xmlCopyAttributeTable: out of memory !\n");
free(ret);	xmlFree(ret);
free(ret->table);	xmlFree(ret->table);
return(NULL);	return(NULL);
}	}
ret->table[i] = cur;	ret->table[i] = cur;
Line 1071 xmlCreateNotationTable(void) {	Line 1072 xmlCreateNotationTable(void) {
xmlNotationTablePtr ret;	xmlNotationTablePtr ret;

ret = (xmlNotationTablePtr)	ret = (xmlNotationTablePtr)
malloc(sizeof(xmlNotationTable));	xmlMalloc(sizeof(xmlNotationTable));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCreateNotationTable : malloc(%ld) failed\n",	fprintf(stderr, "xmlCreateNotationTable : xmlMalloc(%ld) failed\n",
(long)sizeof(xmlNotationTable));	(long)sizeof(xmlNotationTable));
return(NULL);	return(NULL);
}	}
ret->max_notations = XML_MIN_NOTATION_TABLE;	ret->max_notations = XML_MIN_NOTATION_TABLE;
ret->nb_notations = 0;	ret->nb_notations = 0;
ret->table = (xmlNotationPtr *)	ret->table = (xmlNotationPtr *)
malloc(ret->max_notations * sizeof(xmlNotationPtr));	xmlMalloc(ret->max_notations * sizeof(xmlNotationPtr));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCreateNotationTable : malloc(%ld) failed\n",	fprintf(stderr, "xmlCreateNotationTable : xmlMalloc(%ld) failed\n",
ret->max_notations * (long)sizeof(xmlNotation));	ret->max_notations * (long)sizeof(xmlNotation));
free(ret);	xmlFree(ret);
return(NULL);	return(NULL);
}	}
return(ret);	return(ret);
Line 1157 xmlAddNotationDecl(xmlValidCtxtPtr ctxt,	Line 1158 xmlAddNotationDecl(xmlValidCtxtPtr ctxt,
*/	*/
table->max_notations *= 2;	table->max_notations *= 2;
table->table = (xmlNotationPtr *)	table->table = (xmlNotationPtr *)
realloc(table->table, table->max_notations *	xmlRealloc(table->table, table->max_notations *
sizeof(xmlNotationPtr));	sizeof(xmlNotationPtr));
if (table->table == NULL) {	if (table->table == NULL) {
fprintf(stderr, "xmlAddNotationDecl: out of memory\n");	fprintf(stderr, "xmlAddNotationDecl: out of memory\n");
return(NULL);	return(NULL);
}	}
}	}
ret = (xmlNotationPtr) malloc(sizeof(xmlNotation));	ret = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlAddNotationDecl: out of memory\n");	fprintf(stderr, "xmlAddNotationDecl: out of memory\n");
return(NULL);	return(NULL);
Line 1198 void	Line 1199 void
xmlFreeNotation(xmlNotationPtr nota) {	xmlFreeNotation(xmlNotationPtr nota) {
if (nota == NULL) return;	if (nota == NULL) return;
if (nota->name != NULL)	if (nota->name != NULL)
free((CHAR *) nota->name);	xmlFree((CHAR *) nota->name);
if (nota->PublicID != NULL)	if (nota->PublicID != NULL)
free((CHAR *) nota->PublicID);	xmlFree((CHAR *) nota->PublicID);
if (nota->SystemID != NULL)	if (nota->SystemID != NULL)
free((CHAR *) nota->SystemID);	xmlFree((CHAR *) nota->SystemID);
memset(nota, -1, sizeof(xmlNotation));	memset(nota, -1, sizeof(xmlNotation));
free(nota);	xmlFree(nota);
}	}

/**	/**
Line 1222 xmlFreeNotationTable(xmlNotationTablePtr	Line 1223 xmlFreeNotationTable(xmlNotationTablePtr
for (i = 0;i < table->nb_notations;i++) {	for (i = 0;i < table->nb_notations;i++) {
xmlFreeNotation(table->table[i]);	xmlFreeNotation(table->table[i]);
}	}
free(table->table);	xmlFree(table->table);
free(table);	xmlFree(table);
}	}

/**	/**
Line 1240 xmlCopyNotationTable(xmlNotationTablePtr	Line 1241 xmlCopyNotationTable(xmlNotationTablePtr
xmlNotationPtr cur, nota;	xmlNotationPtr cur, nota;
int i;	int i;

ret = (xmlNotationTablePtr) malloc(sizeof(xmlNotationTable));	ret = (xmlNotationTablePtr) xmlMalloc(sizeof(xmlNotationTable));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCopyNotationTable: out of memory !\n");	fprintf(stderr, "xmlCopyNotationTable: out of memory !\n");
return(NULL);	return(NULL);
}	}
ret->table = (xmlNotationPtr ) malloc(table->max_notations	ret->table = (xmlNotationPtr ) xmlMalloc(table->max_notations
sizeof(xmlNotationPtr));	sizeof(xmlNotationPtr));
if (ret->table == NULL) {	if (ret->table == NULL) {
fprintf(stderr, "xmlCopyNotationTable: out of memory !\n");	fprintf(stderr, "xmlCopyNotationTable: out of memory !\n");
free(ret);	xmlFree(ret);
return(NULL);	return(NULL);
}	}
ret->max_notations = table->max_notations;	ret->max_notations = table->max_notations;
ret->nb_notations = table->nb_notations;	ret->nb_notations = table->nb_notations;
for (i = 0;i < ret->nb_notations;i++) {	for (i = 0;i < ret->nb_notations;i++) {
cur = (xmlNotationPtr) malloc(sizeof(xmlNotation));	cur = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
if (cur == NULL) {	if (cur == NULL) {
fprintf(stderr, "xmlCopyNotationTable: out of memory !\n");	fprintf(stderr, "xmlCopyNotationTable: out of memory !\n");
free(ret);	xmlFree(ret);
free(ret->table);	xmlFree(ret->table);
return(NULL);	return(NULL);
}	}
ret->table[i] = cur;	ret->table[i] = cur;
Line 1331 xmlCreateIDTable(void) {	Line 1332 xmlCreateIDTable(void) {
xmlIDTablePtr ret;	xmlIDTablePtr ret;

ret = (xmlIDTablePtr)	ret = (xmlIDTablePtr)
malloc(sizeof(xmlIDTable));	xmlMalloc(sizeof(xmlIDTable));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCreateIDTable : malloc(%ld) failed\n",	fprintf(stderr, "xmlCreateIDTable : xmlMalloc(%ld) failed\n",
(long)sizeof(xmlIDTable));	(long)sizeof(xmlIDTable));
return(NULL);	return(NULL);
}	}
ret->max_ids = XML_MIN_NOTATION_TABLE;	ret->max_ids = XML_MIN_NOTATION_TABLE;
ret->nb_ids = 0;	ret->nb_ids = 0;
ret->table = (xmlIDPtr *)	ret->table = (xmlIDPtr *)
malloc(ret->max_ids * sizeof(xmlIDPtr));	xmlMalloc(ret->max_ids * sizeof(xmlIDPtr));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlCreateIDTable : malloc(%ld) failed\n",	fprintf(stderr, "xmlCreateIDTable : xmlMalloc(%ld) failed\n",
ret->max_ids * (long)sizeof(xmlID));	ret->max_ids * (long)sizeof(xmlID));
free(ret);	xmlFree(ret);
return(NULL);	return(NULL);
}	}
return(ret);	return(ret);
Line 1417 xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr	Line 1418 xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr
*/	*/
table->max_ids *= 2;	table->max_ids *= 2;
table->table = (xmlIDPtr *)	table->table = (xmlIDPtr *)
realloc(table->table, table->max_ids *	xmlRealloc(table->table, table->max_ids *
sizeof(xmlIDPtr));	sizeof(xmlIDPtr));
if (table->table == NULL) {	if (table->table == NULL) {
fprintf(stderr, "xmlAddID: out of memory\n");	fprintf(stderr, "xmlAddID: out of memory\n");
return(NULL);	return(NULL);
}	}
}	}
ret = (xmlIDPtr) malloc(sizeof(xmlID));	ret = (xmlIDPtr) xmlMalloc(sizeof(xmlID));
if (ret == NULL) {	if (ret == NULL) {
fprintf(stderr, "xmlAddID: out of memory\n");	fprintf(stderr, "xmlAddID: out of memory\n");
return(NULL);	return(NULL);
Line 1451 void	Line 1452 void
xmlFreeID(xmlIDPtr id) {	xmlFreeID(xmlIDPtr id) {
if (id == NULL) return;	if (id == NULL) return;
if (id->value != NULL)	if (id->value != NULL)
free((CHAR *) id->value);	xmlFree((CHAR *) id->value);
memset(id, -1, sizeof(xmlID));	memset(id, -1, sizeof(xmlID));
free(id);	xmlFree(id);
}	}

/**	/**
Line 1471 xmlFreeIDTable(xmlIDTablePtr table) {	Line 1472 xmlFreeIDTable(xmlIDTablePtr table) {
for (i = 0;i < table->nb_ids;i++) {	for (i = 0;i < table->nb_ids;i++) {
xmlFreeID(table->table[i]);	xmlFreeID(table->table[i]);
}	}
free(table->table);	xmlFree(table->table);
free(table);	xmlFree(table);
}	}

/**	/**

Webmaster

Removed from v.1.25
changed lines
	Added in v.1.26