lib/libxml2
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/libxml2.git synced 2025-07-29 11:41:22 +03:00
Code Activity

Started working on the hash table module integration, fixed a bug:

Browse Source 
- entities.[ch] xpath.[ch] hash.[ch] debugXML.c tree.h: added/hacked
  hash tables from Bjorn Reese <breese@mail1.stofanet.dk>. Switched
  XPath functions and XML entities table to them. More to come...
- xmlIO.c: fixed libxml closing FILEs it didn't open.
Daniel
This commit is contained in:
Daniel Veillard
2000-10-22 16:56:02 +00:00
parent 683cb02636
commit 52afe800ac
14 changed files with 180 additions and 612 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
ChangeLog
View File

@ -1,3 +1,10 @@
Sun Oct 22 18:39:19 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
* entities.[ch] xpath.[ch] hash.[ch] debugXML.c tree.h: added/hacked
hash tables from Bjorn Reese <breese@mail1.stofanet.dk>. Switched
XPath functions and XML entities table to them. More to come...
* xmlIO.c: fixed libxml closing FILEs it didn't open.
Sun Oct 22 13:59:50 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org> Sun Oct 22 13:59:50 CEST 2000 Daniel Veillard <Daniel.Veillard@w3.org>
* tree.c: coalesce adjacent text nodes * tree.c: coalesce adjacent text nodes

1
Makefile.am
View File

@ -23,6 +23,7 @@ libxml_la_SOURCES = \
parserInternals.c \ parserInternals.c \
parser.c \ parser.c \
tree.c \ tree.c \
hash.c \
xmlIO.c \ xmlIO.c \
xmlmemory.c \ xmlmemory.c \
uri.c \ uri.c \

1
configure.in
View File

@ -264,6 +264,7 @@ AC_SUBST(HTML_OBJ)
AC_ARG_WITH(xpath, [ --with-xpath Add the XPATH support (on)]) AC_ARG_WITH(xpath, [ --with-xpath Add the XPATH support (on)])
if test "$with_xpath" = "no" ; then if test "$with_xpath" = "no" ; then
echo Disabling XPATH support echo Disabling XPATH support
with_xptr="no"
WITH_XPATH=0 WITH_XPATH=0
XPATH_OBJ= XPATH_OBJ=
else else

19
debugXML.c
View File

@ -773,6 +773,7 @@ void xmlDebugDumpDTD(FILE *output, xmlDtdPtr dtd) {
void xmlDebugDumpEntities(FILE *output, xmlDocPtr doc) { void xmlDebugDumpEntities(FILE *output, xmlDocPtr doc) {
int i; int i;
xmlHashEntryPtr ent;
xmlEntityPtr cur; xmlEntityPtr cur;
if (output == NULL) output = stdout; if (output == NULL) output = stdout;
@ -828,9 +829,10 @@ void xmlDebugDumpEntities(FILE *output, xmlDocPtr doc) {
xmlEntitiesTablePtr table = (xmlEntitiesTablePtr) xmlEntitiesTablePtr table = (xmlEntitiesTablePtr)
doc->intSubset->entities; doc->intSubset->entities;
fprintf(output, "Entities in internal subset\n"); fprintf(output, "Entities in internal subset\n");
for (i = 0;i < table->max_entities;i++) { for (i = 0;i < table->size;i++) {
cur = table->table[i]; ent = table->table[i];
while (cur != NULL) { while (ent != NULL) {
cur = (xmlEntityPtr) ent->payload;
fprintf(output, "%d : %s : ", i, cur->name); fprintf(output, "%d : %s : ", i, cur->name);
switch (cur->etype) { switch (cur->etype) {
case XML_INTERNAL_GENERAL_ENTITY: case XML_INTERNAL_GENERAL_ENTITY:
@ -861,7 +863,7 @@ void xmlDebugDumpEntities(FILE *output, xmlDocPtr doc) {
if (cur->content != NULL) if (cur->content != NULL)
fprintf(output, "\n content \"%s\"", cur->content); fprintf(output, "\n content \"%s\"", cur->content);
fprintf(output, "\n"); fprintf(output, "\n");
cur = cur->nexte; ent = ent->next;
} }
} }
} else } else
@ -870,9 +872,10 @@ void xmlDebugDumpEntities(FILE *output, xmlDocPtr doc) {
xmlEntitiesTablePtr table = (xmlEntitiesTablePtr) xmlEntitiesTablePtr table = (xmlEntitiesTablePtr)
doc->extSubset->entities; doc->extSubset->entities;
fprintf(output, "Entities in external subset\n"); fprintf(output, "Entities in external subset\n");
for (i = 0;i < table->max_entities;i++) { for (i = 0;i < table->size;i++) {
cur = table->table[i]; ent = table->table[i];
while (cur != NULL) { while (ent != NULL) {
cur = (xmlEntityPtr) ent->payload;
fprintf(output, "%d : %s : ", i, cur->name); fprintf(output, "%d : %s : ", i, cur->name);
switch (cur->etype) { switch (cur->etype) {
case XML_INTERNAL_GENERAL_ENTITY: case XML_INTERNAL_GENERAL_ENTITY:
@ -903,7 +906,7 @@ void xmlDebugDumpEntities(FILE *output, xmlDocPtr doc) {
if (cur->content != NULL) if (cur->content != NULL)
fprintf(output, "\n content \"%s\"", cur->content); fprintf(output, "\n content \"%s\"", cur->content);
fprintf(output, "\n"); fprintf(output, "\n");
cur = cur->nexte; ent = ent->next;
} }
} }
} else } else

468
entities.c
View File

@ -18,6 +18,7 @@
#include <stdlib.h> #include <stdlib.h>
#endif #endif
#include <libxml/xmlmemory.h> #include <libxml/xmlmemory.h>
#include <libxml/hash.h>
#include <libxml/entities.h> #include <libxml/entities.h>
#include <libxml/parser.h> #include <libxml/parser.h>
@ -60,7 +61,7 @@ struct xmlPredefinedEntityValue xmlPredefinedEntityValues[] = {
* TODO: !!!!!!! This is GROSS, allocation of a 256 entry hash for * TODO: !!!!!!! This is GROSS, allocation of a 256 entry hash for
* a fixed number of 4 elements ! * a fixed number of 4 elements !
*/ */
xmlEntitiesTablePtr xmlPredefinedEntities = NULL; xmlHashTablePtr xmlPredefinedEntities = NULL;
/* /*
* xmlFreeEntity : clean-up an entity record. * xmlFreeEntity : clean-up an entity record.
@ -82,15 +83,6 @@ void xmlFreeEntity(xmlEntityPtr entity) {
xmlFree((char *) entity->content); xmlFree((char *) entity->content);
if (entity->orig != NULL) if (entity->orig != NULL)
xmlFree((char *) entity->orig); xmlFree((char *) entity->orig);
#ifdef WITH_EXTRA_ENT_DETECT
if (entity->entTab != NULL) {
int i;
for (i = 0; i < entity->entNr; i++)
xmlFree(entity->entTab[i]);
xmlFree(entity->entTab);
}
#endif
memset(entity, -1, sizeof(xmlEntity)); memset(entity, -1, sizeof(xmlEntity));
xmlFree(entity); xmlFree(entity);
} }
@ -99,77 +91,35 @@ void xmlFreeEntity(xmlEntityPtr entity) {
* xmlAddEntity : register a new entity for an entities table. * xmlAddEntity : register a new entity for an entities table.
*/ */
static xmlEntityPtr static xmlEntityPtr
xmlAddEntity(xmlEntitiesTablePtr table, const xmlChar *name, int type, xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type,
const xmlChar *ExternalID, const xmlChar *SystemID, const xmlChar *ExternalID, const xmlChar *SystemID,
const xmlChar *content) { const xmlChar *content) {
#ifndef ENTITY_HASH_SIZE xmlEntitiesTablePtr table = NULL;
int i;
#endif
int hash;
xmlEntityPtr ret; xmlEntityPtr ret;
if (name == NULL) if (name == NULL)
return(NULL); return(NULL);
#ifdef ENTITY_HASH_SIZE switch (type) {
hash = xmlEntityComputeHash(name); case XML_INTERNAL_GENERAL_ENTITY:
ret = table->table[hash]; case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
while (ret != NULL) { case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
if (xmlStrEqual(ret->name, name)) { if (dtd->entities == NULL)
/* dtd->entities = xmlHashCreate(0);
* The entity is already defined in this Dtd, the spec says to NOT table = dtd->entities;
* override it ... Is it worth a Warning ??? !!! break;
* Not having a cprinting context this seems hard ... case XML_INTERNAL_PARAMETER_ENTITY:
*/ case XML_EXTERNAL_PARAMETER_ENTITY:
if (((type == XML_INTERNAL_PARAMETER_ENTITY) || if (dtd->pentities == NULL)
(type == XML_EXTERNAL_PARAMETER_ENTITY)) && dtd->pentities = xmlHashCreate(0);
((ret->etype == XML_INTERNAL_PARAMETER_ENTITY) || table = dtd->pentities;
(ret->etype == XML_EXTERNAL_PARAMETER_ENTITY))) break;
return(NULL); case XML_INTERNAL_PREDEFINED_ENTITY:
else if (xmlPredefinedEntities == NULL)
if (((type != XML_INTERNAL_PARAMETER_ENTITY) && xmlPredefinedEntities = xmlHashCreate(8);
(type != XML_EXTERNAL_PARAMETER_ENTITY)) && table = xmlPredefinedEntities;
((ret->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
(ret->etype != XML_EXTERNAL_PARAMETER_ENTITY)))
return(NULL);
}
ret = ret->nexte;
} }
#else if (table == NULL)
for (i = 0;i < table->nb_entities;i++) { return(NULL);
ret = table->table[i];
if (xmlStrEqual(ret->name, name)) {
/*
* The entity is already defined in this Dtd, the spec says to NOT
* override it ... Is it worth a Warning ??? !!!
* Not having a cprinting context this seems hard ...
*/
if (((type == XML_INTERNAL_PARAMETER_ENTITY) ||
(type == XML_EXTERNAL_PARAMETER_ENTITY)) &&
((ret->etype == XML_INTERNAL_PARAMETER_ENTITY) ||
(ret->etype == XML_EXTERNAL_PARAMETER_ENTITY)))
return(NULL);
else
if (((type != XML_INTERNAL_PARAMETER_ENTITY) &&
(type != XML_EXTERNAL_PARAMETER_ENTITY)) &&
((ret->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
(ret->etype != XML_EXTERNAL_PARAMETER_ENTITY)))
return(NULL);
}
}
if (table->nb_entities >= table->max_entities) {
/*
* need more elements.
*/
table->max_entities *= 2;
table->table = (xmlEntityPtr *)
xmlRealloc(table->table,
table->max_entities * sizeof(xmlEntityPtr));
if (table->table == NULL) {
perror("realloc failed");
return(NULL);
}
}
#endif
ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity)); ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
if (ret == NULL) { if (ret == NULL) {
fprintf(stderr, "xmlAddEntity: out of memory\n"); fprintf(stderr, "xmlAddEntity: out of memory\n");
@ -177,12 +127,6 @@ xmlAddEntity(xmlEntitiesTablePtr table, const xmlChar *name, int type,
} }
memset(ret, 0, sizeof(xmlEntity)); memset(ret, 0, sizeof(xmlEntity));
ret->type = XML_ENTITY_DECL; ret->type = XML_ENTITY_DECL;
#ifdef ENTITY_HASH_SIZE
ret->nexte = table->table[hash];
table->table[hash] = ret;
#else
table->table[table->nb_entities] = ret;
#endif
/* /*
* fill the structure. * fill the structure.
@ -203,8 +147,13 @@ xmlAddEntity(xmlEntitiesTablePtr table, const xmlChar *name, int type,
ret->URI = NULL; /* to be computed by the layer knowing ret->URI = NULL; /* to be computed by the layer knowing
the defining entity */ the defining entity */
ret->orig = NULL; ret->orig = NULL;
table->nb_entities++;
if (xmlHashAddEntry(table, name, ret)) {
/*
* entity was already defined at another level.
*/
xmlFreeEntity(ret);
}
return(ret); return(ret);
} }
@ -231,7 +180,8 @@ void xmlInitializePredefinedEntities(void) {
in = xmlPredefinedEntityValues[i].value; in = xmlPredefinedEntityValues[i].value;
out = &value[0]; out = &value[0];
for (;(*out++ = (xmlChar) *in);)in++; for (;(*out++ = (xmlChar) *in);)in++;
xmlAddEntity(xmlPredefinedEntities, (const xmlChar *) &name[0],
xmlAddEntity(NULL, (const xmlChar *) &name[0],
XML_INTERNAL_PREDEFINED_ENTITY, NULL, NULL, XML_INTERNAL_PREDEFINED_ENTITY, NULL, NULL,
&value[0]); &value[0]);
} }
@ -259,26 +209,9 @@ void xmlCleanupPredefinedEntities(void) {
*/ */
xmlEntityPtr xmlEntityPtr
xmlGetPredefinedEntity(const xmlChar *name) { xmlGetPredefinedEntity(const xmlChar *name) {
int i;
xmlEntityPtr cur;
if (xmlPredefinedEntities == NULL) if (xmlPredefinedEntities == NULL)
xmlInitializePredefinedEntities(); xmlInitializePredefinedEntities();
#ifdef ENTITY_HASH_SIZE return((xmlEntityPtr) xmlHashLookup(xmlPredefinedEntities, name));
i = xmlEntityComputeHash(name);
cur = xmlPredefinedEntities->table[i];
while (cur != NULL) {
if (xmlStrEqual(cur->name, name))
return(cur);
cur = cur->nexte;
}
#else
for (i = 0;i < xmlPredefinedEntities->nb_entities;i++) {
cur = xmlPredefinedEntities->table[i];
if (xmlStrEqual(cur->name, name)) return(cur);
}
#endif
return(NULL);
} }
/** /**
@ -298,7 +231,6 @@ xmlEntityPtr
xmlAddDtdEntity(xmlDocPtr doc, const xmlChar *name, int type, xmlAddDtdEntity(xmlDocPtr doc, const xmlChar *name, int type,
const xmlChar *ExternalID, const xmlChar *SystemID, const xmlChar *ExternalID, const xmlChar *SystemID,
const xmlChar *content) { const xmlChar *content) {
xmlEntitiesTablePtr table;
xmlEntityPtr ret; xmlEntityPtr ret;
xmlDtdPtr dtd; xmlDtdPtr dtd;
@ -313,12 +245,7 @@ xmlAddDtdEntity(xmlDocPtr doc, const xmlChar *name, int type,
return(NULL); return(NULL);
} }
dtd = doc->extSubset; dtd = doc->extSubset;
table = (xmlEntitiesTablePtr) dtd->entities; ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
if (table == NULL) {
table = xmlCreateEntitiesTable();
dtd->entities = table;
}
ret = xmlAddEntity(table, name, type, ExternalID, SystemID, content);
if (ret == NULL) return(NULL); if (ret == NULL) return(NULL);
/* /*
@ -353,7 +280,6 @@ xmlEntityPtr
xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type, xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type,
const xmlChar *ExternalID, const xmlChar *SystemID, const xmlChar *ExternalID, const xmlChar *SystemID,
const xmlChar *content) { const xmlChar *content) {
xmlEntitiesTablePtr table;
xmlEntityPtr ret; xmlEntityPtr ret;
xmlDtdPtr dtd; xmlDtdPtr dtd;
@ -368,12 +294,7 @@ xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type,
return(NULL); return(NULL);
} }
dtd = doc->intSubset; dtd = doc->intSubset;
table = (xmlEntitiesTablePtr) doc->intSubset->entities; ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
if (table == NULL) {
table = xmlCreateEntitiesTable();
doc->intSubset->entities = table;
}
ret = xmlAddEntity(table, name, type, ExternalID, SystemID, content);
if (ret == NULL) return(NULL); if (ret == NULL) return(NULL);
/* /*
@ -391,143 +312,6 @@ xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type,
return(ret); return(ret);
} }
#ifdef WITH_EXTRA_ENT_DETECT
/**
* xmlEntityCheckReference:
* @ent: an existing entity
* @to: the entity name it's referencing
*
* Function to keep track of references and detect cycles (well formedness
* errors !).
*
* Returns: 0 if Okay, -1 in case of general error, 1 in case of loop
* detection.
*/
int
xmlEntityCheckReference(xmlEntityPtr ent, const xmlChar *to) {
int i;
xmlDocPtr doc;
if (ent == NULL) return(-1);
if (to == NULL) return(-1);
doc = ent->doc;
if (doc == NULL) return(-1);
#ifdef DEBUG_ENT_REF
printf("xmlEntityCheckReference(%s to %s)\n", ent->name, to);
#endif
/*
* Do a recursive checking
*/
for (i = 0;i < ent->entNr;i++) {
xmlEntityPtr indir = NULL;
if (xmlStrEqual(to, ent->entTab[i]))
return(1);
switch (ent->etype) {
case XML_INTERNAL_GENERAL_ENTITY:
case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
indir = xmlGetDocEntity(doc, ent->entTab[i]);
break;
case XML_INTERNAL_PARAMETER_ENTITY:
case XML_EXTERNAL_PARAMETER_ENTITY:
indir = xmlGetDtdEntity(doc, ent->entTab[i]);
break;
case XML_INTERNAL_PREDEFINED_ENTITY:
case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
break;
}
if (xmlEntityCheckReference(indir, to) == 1)
return(1);
}
return(0);
}
/**
* xmlEntityAddReference:
* @ent: an existing entity
* @to: the entity name it's referencing
*
* Function to register reuse of an existing entity from a (new) one
* Used to keep track of references and detect cycles (well formedness
* errors !).
*
* Returns: 0 if Okay, -1 in case of general error, 1 in case of loop
* detection.
*/
int
xmlEntityAddReference(xmlEntityPtr ent, const xmlChar *to) {
int i;
xmlDocPtr doc;
xmlEntityPtr indir = NULL;
if (ent == NULL) return(-1);
if (to == NULL) return(-1);
doc = ent->doc;
if (doc == NULL) return(-1);
#ifdef DEBUG_ENT_REF
printf("xmlEntityAddReference(%s to %s)\n", ent->name, to);
#endif
if (ent->entTab == NULL) {
ent->entNr = 0;
ent->entMax = 5;
ent->entTab = (xmlChar **) xmlMalloc(ent->entMax * sizeof(xmlChar *));
if (ent->entTab == NULL) {
fprintf(stderr, "xmlEntityAddReference: out of memory !\n");
return(-1);
}
}
for (i = 0;i < ent->entNr;i++) {
if (xmlStrEqual(to, ent->entTab[i]))
return(0);
}
/*
* Do a recursive checking
*/
switch (ent->etype) {
case XML_INTERNAL_GENERAL_ENTITY:
case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
indir = xmlGetDocEntity(doc, to);
break;
case XML_INTERNAL_PARAMETER_ENTITY:
case XML_EXTERNAL_PARAMETER_ENTITY:
indir = xmlGetDtdEntity(doc, to);
break;
case XML_INTERNAL_PREDEFINED_ENTITY:
case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
break;
}
if ((indir != NULL) &&
(xmlEntityCheckReference(indir, ent->name) == 1))
return(1);
/*
* Add this to the list
*/
if (ent->entMax <= ent->entNr) {
ent->entMax *= 2;
ent->entTab = (xmlChar **) xmlRealloc(ent->entTab,
ent->entMax * sizeof(xmlChar *));
if (ent->entTab == NULL) {
fprintf(stderr, "xmlEntityAddReference: out of memory !\n");
return(-1);
}
}
ent->entTab[ent->entNr++] = xmlStrdup(to);
return(0);
}
#endif
/** /**
* xmlGetEntityFromTable: * xmlGetEntityFromTable:
* @table: an entity table * @table: an entity table
@ -540,43 +324,8 @@ xmlEntityAddReference(xmlEntityPtr ent, const xmlChar *to) {
* Returns A pointer to the entity structure or NULL if not found. * Returns A pointer to the entity structure or NULL if not found.
*/ */
xmlEntityPtr xmlEntityPtr
xmlGetEntityFromTable(xmlEntitiesTablePtr table, const xmlChar *name, xmlGetEntityFromTable(xmlEntitiesTablePtr table, const xmlChar *name) {
int parameter) { return((xmlEntityPtr) xmlHashLookup(table, name));
xmlEntityPtr cur;
#ifdef ENTITY_HASH_SIZE
int hash;
hash = xmlEntityComputeHash(name);
cur = table->table[hash];
while (cur != NULL) {
switch (cur->etype) {
case XML_INTERNAL_PARAMETER_ENTITY:
case XML_EXTERNAL_PARAMETER_ENTITY:
if ((parameter) && (xmlStrEqual(cur->name, name)))
return(cur);
default:
if ((!parameter) && (xmlStrEqual(cur->name, name)))
return(cur);
}
cur = cur->nexte;
}
#else
int i;
for (i = 0;i < table->nb_entities;i++) {
cur = table->table[i];
switch (cur->etype) {
case XML_INTERNAL_PARAMETER_ENTITY:
case XML_EXTERNAL_PARAMETER_ENTITY:
if ((parameter) && (xmlStrEqual(cur->name, name)))
return(cur);
default:
if ((!parameter) && (xmlStrEqual(cur->name, name)))
return(cur);
}
}
#endif
return(NULL);
} }
/** /**
@ -594,15 +343,15 @@ xmlGetParameterEntity(xmlDocPtr doc, const xmlChar *name) {
xmlEntitiesTablePtr table; xmlEntitiesTablePtr table;
xmlEntityPtr ret; xmlEntityPtr ret;
if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) { if ((doc->intSubset != NULL) && (doc->intSubset->pentities != NULL)) {
table = (xmlEntitiesTablePtr) doc->intSubset->entities; table = (xmlEntitiesTablePtr) doc->intSubset->pentities;
ret = xmlGetEntityFromTable(table, name, 1); ret = xmlGetEntityFromTable(table, name);
if (ret != NULL) if (ret != NULL)
return(ret); return(ret);
} }
if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) { if ((doc->extSubset != NULL) && (doc->extSubset->pentities != NULL)) {
table = (xmlEntitiesTablePtr) doc->extSubset->entities; table = (xmlEntitiesTablePtr) doc->extSubset->pentities;
return(xmlGetEntityFromTable(table, name, 1)); return(xmlGetEntityFromTable(table, name));
} }
return(NULL); return(NULL);
} }
@ -623,7 +372,7 @@ xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) {
if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) { if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->extSubset->entities; table = (xmlEntitiesTablePtr) doc->extSubset->entities;
return(xmlGetEntityFromTable(table, name, 0)); return(xmlGetEntityFromTable(table, name));
} }
return(NULL); return(NULL);
} }
@ -647,13 +396,13 @@ xmlGetDocEntity(xmlDocPtr doc, const xmlChar *name) {
if (doc != NULL) { if (doc != NULL) {
if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) { if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->intSubset->entities; table = (xmlEntitiesTablePtr) doc->intSubset->entities;
cur = xmlGetEntityFromTable(table, name, 0); cur = xmlGetEntityFromTable(table, name);
if (cur != NULL) if (cur != NULL)
return(cur); return(cur);
} }
if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) { if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->extSubset->entities; table = (xmlEntitiesTablePtr) doc->extSubset->entities;
cur = xmlGetEntityFromTable(table, name, 0); cur = xmlGetEntityFromTable(table, name);
if (cur != NULL) if (cur != NULL)
return(cur); return(cur);
} }
@ -661,7 +410,7 @@ xmlGetDocEntity(xmlDocPtr doc, const xmlChar *name) {
if (xmlPredefinedEntities == NULL) if (xmlPredefinedEntities == NULL)
xmlInitializePredefinedEntities(); xmlInitializePredefinedEntities();
table = xmlPredefinedEntities; table = xmlPredefinedEntities;
return(xmlGetEntityFromTable(table, name, 0)); return(xmlGetEntityFromTable(table, name));
} }
/* /*
@ -1117,39 +866,7 @@ xmlEncodeSpecialChars(xmlDocPtr doc, const xmlChar *input) {
*/ */
xmlEntitiesTablePtr xmlEntitiesTablePtr
xmlCreateEntitiesTable(void) { xmlCreateEntitiesTable(void) {
xmlEntitiesTablePtr ret; return((xmlEntitiesTablePtr) xmlHashCreate(0));
ret = (xmlEntitiesTablePtr)
xmlMalloc(sizeof(xmlEntitiesTable));
if (ret == NULL) {
fprintf(stderr, "xmlCreateEntitiesTable : xmlMalloc(%ld) failed\n",
(long)sizeof(xmlEntitiesTable));
return(NULL);
}
ret->nb_entities = 0;
#ifdef ENTITY_HASH_SIZE
ret->max_entities = ENTITY_HASH_SIZE;
ret->table = (xmlEntityPtr *)
xmlMalloc(ret->max_entities * sizeof(xmlEntityPtr));
if (ret == NULL) {
fprintf(stderr, "xmlCreateEntitiesTable : xmlMalloc(%ld) failed\n",
ret->max_entities * (long)sizeof(xmlEntityPtr));
xmlFree(ret);
return(NULL);
}
memset(ret->table, 0, ret->max_entities * sizeof(xmlEntityPtr));
#else
ret->max_entities = XML_MIN_ENTITIES_TABLE;
ret->table = (xmlEntityPtr *)
xmlMalloc(ret->max_entities * sizeof(xmlEntityPtr));
if (ret == NULL) {
fprintf(stderr, "xmlCreateEntitiesTable : xmlMalloc(%ld) failed\n",
ret->max_entities * (long)sizeof(xmlEntityPtr));
xmlFree(ret);
return(NULL);
}
#endif
return(ret);
} }
/** /**
@ -1160,29 +877,7 @@ xmlCreateEntitiesTable(void) {
*/ */
void void
xmlFreeEntitiesTable(xmlEntitiesTablePtr table) { xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
int i; xmlHashFree(table, (xmlHashDeallocator) xmlFreeEntity);
#ifdef ENTITY_HASH_SIZE
xmlEntityPtr cur, next;
#endif
if (table == NULL) return;
#ifdef ENTITY_HASH_SIZE
for (i = 0;i < ENTITY_HASH_SIZE;i++) {
cur = table->table[i];
while (cur != NULL) {
next = cur->nexte;
xmlFreeEntity(cur);
cur = next;
}
}
#else
for (i = 0;i < table->nb_entities;i++) {
xmlFreeEntity(table->table[i]);
}
#endif
xmlFree(table->table);
xmlFree(table);
} }
/** /**
@ -1229,50 +924,7 @@ xmlCopyEntity(xmlEntityPtr ent) {
*/ */
xmlEntitiesTablePtr xmlEntitiesTablePtr
xmlCopyEntitiesTable(xmlEntitiesTablePtr table) { xmlCopyEntitiesTable(xmlEntitiesTablePtr table) {
xmlEntitiesTablePtr ret; return(xmlHashCopy(table, (xmlHashCopier) xmlCopyEntity));
xmlEntityPtr cur, ent;
int i;
ret = (xmlEntitiesTablePtr) xmlMalloc(sizeof(xmlEntitiesTable));
if (ret == NULL) {
fprintf(stderr, "xmlCopyEntitiesTable: out of memory !\n");
return(NULL);
}
#ifdef ENTITY_HASH_SIZE
ret->table = (xmlEntityPtr *) xmlMalloc(ENTITY_HASH_SIZE *
sizeof(xmlEntityPtr));
if (ret->table == NULL) {
fprintf(stderr, "xmlCopyEntitiesTable: out of memory !\n");
xmlFree(ret);
return(NULL);
}
#else
ret->table = (xmlEntityPtr *) xmlMalloc(table->max_entities *
sizeof(xmlEntityPtr));
if (ret->table == NULL) {
fprintf(stderr, "xmlCopyEntitiesTable: out of memory !\n");
xmlFree(ret);
return(NULL);
}
#endif
ret->max_entities = table->max_entities;
ret->nb_entities = table->nb_entities;
for (i = 0;i < ret->nb_entities;i++) {
ent = table->table[i];
if (ent == NULL)
cur = NULL;
else
cur = xmlCopyEntity(ent);
ret->table[i] = cur;
#ifdef ENTITY_HASH_SIZE
ent = ent->nexte;
while ((ent != NULL) && (cur != NULL)) {
cur->nexte = xmlCopyEntity(ent);
cur = cur->nexte;
}
#endif
}
return(ret);
} }
/** /**
@ -1370,23 +1022,5 @@ xmlDumpEntityDecl(xmlBufferPtr buf, xmlEntityPtr ent) {
*/ */
void void
xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) { xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) {
int i; xmlHashScan(table, (xmlHashScanner)xmlDumpEntityDecl, buf);
xmlEntityPtr cur;
if (table == NULL) return;
#ifdef ENTITY_HASH_SIZE
for (i = 0;i < ENTITY_HASH_SIZE;i++) {
cur = table->table[i];
while (cur != NULL) {
xmlDumpEntityDecl(buf, cur);
cur = cur->nexte;
}
}
#else
for (i = 0;i < table->nb_entities;i++) {
cur = table->table[i];
xmlDumpEntityDecl(buf, cur);
}
#endif
} }

28
entities.h
View File

@ -54,33 +54,17 @@ struct _xmlEntity {
const xmlChar *ExternalID; /* External identifier for PUBLIC */ const xmlChar *ExternalID; /* External identifier for PUBLIC */
const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC Entity */ const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC Entity */
struct _xmlEntity *nexte; /* next entity in the hash table */ struct _xmlEntity *nexte; /* unused */
const xmlChar *URI; /* the full URI as computed */ const xmlChar *URI; /* the full URI as computed */
#ifdef WITH_EXTRA_ENT_DETECT
/* Referenced entities name stack */
xmlChar *ent; /* Current parsed Node */
int entNr; /* Depth of the parsing stack */
int entMax; /* Max depth of the parsing stack */
xmlChar * *entTab; /* array of nodes */
#endif
}; };
/* /*
* ALl entities are stored in a table there is one table per DTD * ALl entities are stored in an hash table
* and one extra per document. * there is 2 separate hash tables for global and parmeter entities
*/ */
#define XML_MIN_ENTITIES_TABLE 32 typedef struct _xmlHashTable xmlEntitiesTable;
typedef struct _xmlEntitiesTable xmlEntitiesTable;
typedef xmlEntitiesTable *xmlEntitiesTablePtr; typedef xmlEntitiesTable *xmlEntitiesTablePtr;
struct _xmlEntitiesTable {
int nb_entities; /* number of elements stored */
int max_entities; /* maximum number of elements */
xmlEntityPtr *table; /* the table of entities */
};
/* /*
* External functions : * External functions :
@ -122,10 +106,6 @@ void xmlDumpEntityDecl (xmlBufferPtr buf,
xmlEntitiesTablePtr xmlCopyEntitiesTable (xmlEntitiesTablePtr table); xmlEntitiesTablePtr xmlCopyEntitiesTable (xmlEntitiesTablePtr table);
void xmlCleanupPredefinedEntities(void); void xmlCleanupPredefinedEntities(void);
#ifdef WITH_EXTRA_ENT_DETECT
int xmlEntityAddReference (xmlEntityPtr ent,
const xmlChar *to);
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }

1
include/Makefile.am
View File

@ -14,6 +14,7 @@ xmlinc_HEADERS = \
libxml/HTMLtree.h \ libxml/HTMLtree.h \
libxml/debugXML.h \ libxml/debugXML.h \
libxml/tree.h \ libxml/tree.h \
libxml/hash.h \
libxml/xpath.h \ libxml/xpath.h \
libxml/xpointer.h \ libxml/xpointer.h \
libxml/xmlIO.h \ libxml/xmlIO.h \

28
include/libxml/entities.h
View File

@ -54,33 +54,17 @@ struct _xmlEntity {
const xmlChar *ExternalID; /* External identifier for PUBLIC */ const xmlChar *ExternalID; /* External identifier for PUBLIC */
const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC Entity */ const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC Entity */
struct _xmlEntity *nexte; /* next entity in the hash table */ struct _xmlEntity *nexte; /* unused */
const xmlChar *URI; /* the full URI as computed */ const xmlChar *URI; /* the full URI as computed */
#ifdef WITH_EXTRA_ENT_DETECT
/* Referenced entities name stack */
xmlChar *ent; /* Current parsed Node */
int entNr; /* Depth of the parsing stack */
int entMax; /* Max depth of the parsing stack */
xmlChar * *entTab; /* array of nodes */
#endif
}; };
/* /*
* ALl entities are stored in a table there is one table per DTD * ALl entities are stored in an hash table
* and one extra per document. * there is 2 separate hash tables for global and parmeter entities
*/ */
#define XML_MIN_ENTITIES_TABLE 32 typedef struct _xmlHashTable xmlEntitiesTable;
typedef struct _xmlEntitiesTable xmlEntitiesTable;
typedef xmlEntitiesTable *xmlEntitiesTablePtr; typedef xmlEntitiesTable *xmlEntitiesTablePtr;
struct _xmlEntitiesTable {
int nb_entities; /* number of elements stored */
int max_entities; /* maximum number of elements */
xmlEntityPtr *table; /* the table of entities */
};
/* /*
* External functions : * External functions :
@ -122,10 +106,6 @@ void xmlDumpEntityDecl (xmlBufferPtr buf,
xmlEntitiesTablePtr xmlCopyEntitiesTable (xmlEntitiesTablePtr table); xmlEntitiesTablePtr xmlCopyEntitiesTable (xmlEntitiesTablePtr table);
void xmlCleanupPredefinedEntities(void); void xmlCleanupPredefinedEntities(void);
#ifdef WITH_EXTRA_ENT_DETECT
int xmlEntityAddReference (xmlEntityPtr ent,
const xmlChar *to);
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }

1
include/libxml/tree.h
View File

@ -233,6 +233,7 @@ struct _xmlDtd {
void *entities; /* Hash table for entities if any */ void *entities; /* Hash table for entities if any */
const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */ const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */
const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */ const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */
void *pentities; /* Hash table for param entities if any */
}; };
/* /*

7
include/libxml/xpath.h
View File

@ -13,6 +13,7 @@
#define __XML_XPATH_H__ #define __XML_XPATH_H__
#include <libxml/tree.h> #include <libxml/tree.h>
#include <libxml/hash.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -184,9 +185,9 @@ struct _xmlXPathContext {
int max_types; /* max number of types */ int max_types; /* max number of types */
xmlXPathTypePtr types; /* Array of defined types */ xmlXPathTypePtr types; /* Array of defined types */
int nb_funcs; /* number of defined funcs */ int nb_funcs_unused; /* unused (hash table) */
int max_funcs; /* max number of funcs */ int max_funcs_unused; /* unused (hash table) */
xmlXPathFuncPtr funcs; /* Array of defined funcs */ xmlHashTablePtr funcHash; /* Hash table of defined funcs */
int nb_axis; /* number of defined axis */ int nb_axis; /* number of defined axis */
int max_axis; /* max number of axis */ int max_axis; /* max number of axis */

1
tree.h
View File

@ -233,6 +233,7 @@ struct _xmlDtd {
void *entities; /* Hash table for entities if any */ void *entities; /* Hash table for entities if any */
const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */ const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */
const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */ const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */
void *pentities; /* Hash table for param entities if any */
}; };
/* /*

15
xmlIO.c
View File

@ -340,6 +340,17 @@ xmlFileClose (void * context) {
fclose((FILE *) context); fclose((FILE *) context);
} }
/**
* xmlFileFlush:
* @context: the I/O context
*
* Flush an I/O channel
*/
void
xmlFileFlush (void * context) {
fflush((FILE *) context);
}
#ifdef HAVE_ZLIB_H #ifdef HAVE_ZLIB_H
/************************************************************************ /************************************************************************
* * * *
@ -990,7 +1001,7 @@ xmlParserInputBufferCreateFile(FILE *file, xmlCharEncoding enc) {
if (ret != NULL) { if (ret != NULL) {
ret->context = file; ret->context = file;
ret->readcallback = xmlFileRead; ret->readcallback = xmlFileRead;
ret->closecallback = xmlFileClose; ret->closecallback = xmlFileFlush;
} }
return(ret); return(ret);
@ -1019,7 +1030,7 @@ xmlOutputBufferCreateFile(FILE *file, xmlCharEncodingHandlerPtr encoder) {
if (ret != NULL) { if (ret != NULL) {
ret->context = file; ret->context = file;
ret->writecallback = xmlFileWrite; ret->writecallback = xmlFileWrite;
ret->closecallback = xmlFileClose; ret->closecallback = xmlFileFlush;
} }
return(ret); return(ret);

208
xpath.c
View File

@ -49,6 +49,7 @@
#include <libxml/valid.h> #include <libxml/valid.h>
#include <libxml/xpath.h> #include <libxml/xpath.h>
#include <libxml/parserInternals.h> #include <libxml/parserInternals.h>
#include <libxml/hash.h>
#ifdef LIBXML_XPTR_ENABLED #ifdef LIBXML_XPTR_ENABLED
#include <libxml/xpointer.h> #include <libxml/xpointer.h>
#endif #endif
@ -184,6 +185,7 @@ FILE *xmlXPathDebug = NULL;
#ifdef LIBXML_DEBUG_ENABLED #ifdef LIBXML_DEBUG_ENABLED
double xmlXPathStringEvalNumber(const xmlChar *str); double xmlXPathStringEvalNumber(const xmlChar *str);
void xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt);
void xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) { void xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
int i; int i;
@ -832,40 +834,16 @@ xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
int int
xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name, xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
xmlXPathFunction f) { xmlXPathFunction f) {
int i;
if (ctxt == NULL) if (ctxt == NULL)
return(-1); return(-1);
if (name == NULL) if (name == NULL)
return(-1); return(-1);
for (i = 0;i < ctxt->nb_funcs;i++) { if (ctxt->funcHash == NULL)
if (xmlStrEqual(ctxt->funcs[i].name, name)) { ctxt->funcHash = xmlHashCreate(0);
/* if (ctxt->funcHash == NULL)
* It's just an update or a removal
*/
ctxt->funcs[i].func = f;
return(0);
}
}
if (ctxt->max_funcs <= 0) {
ctxt->max_funcs = 10;
ctxt->nb_funcs = 0;
ctxt->funcs = (xmlXPathFuncPtr) xmlMalloc(ctxt->max_funcs *
sizeof(xmlXPathFunct));
} else if (ctxt->max_funcs <= ctxt->nb_funcs) {
ctxt->max_funcs *= 2;
ctxt->funcs = (xmlXPathFuncPtr) xmlRealloc(ctxt->funcs,
ctxt->max_funcs * sizeof(xmlXPathFunct));
}
if (ctxt->funcs == NULL) {
fprintf(xmlXPathDebug, "xmlXPathRegisterFunc: out of memory\n");
return(-1); return(-1);
} return(xmlHashAddEntry(ctxt->funcHash, name, (void *) f));
ctxt->funcs[ctxt->nb_funcs].name = xmlStrdup(name);
ctxt->funcs[ctxt->nb_funcs].func = f;
ctxt->nb_funcs++;
return(0);
} }
/** /**
@ -880,19 +858,14 @@ xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
*/ */
xmlXPathFunction xmlXPathFunction
xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) { xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
int i;
if (ctxt == NULL) if (ctxt == NULL)
return(NULL); return(NULL);
if (ctxt->funcHash == NULL)
return(NULL);
if (name == NULL) if (name == NULL)
return(NULL); return(NULL);
for (i = 0;i < ctxt->nb_funcs;i++) { return((xmlXPathFunction) xmlHashLookup(ctxt->funcHash, name));
if (xmlStrEqual(ctxt->funcs[i].name, name)) {
return(ctxt->funcs[i].func);
}
}
return(NULL);
} }
/** /**
@ -903,19 +876,11 @@ xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
*/ */
void void
xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) { xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
int i;
if (ctxt == NULL) if (ctxt == NULL)
return; return;
for (i = 0;i < ctxt->nb_funcs;i++) { xmlHashFree(ctxt->funcHash, NULL);
xmlFree((xmlChar *) ctxt->funcs[i].name); ctxt->funcHash = NULL;
}
ctxt->nb_funcs = -1;
ctxt->max_funcs = -1;
if (ctxt->funcs != NULL)
xmlFree(ctxt->funcs);
ctxt->funcs = NULL;
} }
/************************************************************************ /************************************************************************
@ -1239,9 +1204,7 @@ xmlXPathNewContext(xmlDocPtr doc) {
ret->max_types = 0; ret->max_types = 0;
ret->types = NULL; ret->types = NULL;
ret->nb_funcs = 0; ret->funcHash = xmlHashCreate(0);
ret->max_funcs = 0;
ret->funcs = NULL;
ret->nb_axis = 0; ret->nb_axis = 0;
ret->max_axis = 0; ret->max_axis = 0;
@ -1253,6 +1216,9 @@ xmlXPathNewContext(xmlDocPtr doc) {
ret->contextSize = -1; ret->contextSize = -1;
ret->proximityPosition = -1; ret->proximityPosition = -1;
xmlXPathRegisterAllFunctions(ret);
return(ret); return(ret);
} }
@ -4012,88 +3978,7 @@ xmlXPathIsNodeType(const xmlChar *name) {
*/ */
xmlXPathFunction xmlXPathFunction
xmlXPathIsFunction(xmlXPathParserContextPtr ctxt, const xmlChar *name) { xmlXPathIsFunction(xmlXPathParserContextPtr ctxt, const xmlChar *name) {
if (name == NULL) return((xmlXPathFunction) xmlHashLookup(ctxt->context->funcHash, name));
return(NULL);
switch (name[0]) {
case 'b':
if (xmlStrEqual(name, BAD_CAST "boolean"))
return(xmlXPathBooleanFunction);
break;
case 'c':
if (xmlStrEqual(name, BAD_CAST "ceiling"))
return(xmlXPathCeilingFunction);
if (xmlStrEqual(name, BAD_CAST "count"))
return(xmlXPathCountFunction);
if (xmlStrEqual(name, BAD_CAST "concat"))
return(xmlXPathConcatFunction);
if (xmlStrEqual(name, BAD_CAST "contains"))
return(xmlXPathContainsFunction);
break;
case 'i':
if (xmlStrEqual(name, BAD_CAST "id"))
return(xmlXPathIdFunction);
break;
case 'f':
if (xmlStrEqual(name, BAD_CAST "false"))
return(xmlXPathFalseFunction);
if (xmlStrEqual(name, BAD_CAST "floor"))
return(xmlXPathFloorFunction);
break;
case 'l':
if (xmlStrEqual(name, BAD_CAST "last"))
return(xmlXPathLastFunction);
if (xmlStrEqual(name, BAD_CAST "lang"))
return(xmlXPathLangFunction);
if (xmlStrEqual(name, BAD_CAST "local-part"))
return(xmlXPathLocalPartFunction);
break;
case 'n':
if (xmlStrEqual(name, BAD_CAST "not"))
return(xmlXPathNotFunction);
if (xmlStrEqual(name, BAD_CAST "name"))
return(xmlXPathNameFunction);
if (xmlStrEqual(name, BAD_CAST "namespace"))
return(xmlXPathNamespaceFunction);
if (xmlStrEqual(name, BAD_CAST "normalize-space"))
return(xmlXPathNormalizeFunction);
if (xmlStrEqual(name, BAD_CAST "normalize"))
return(xmlXPathNormalizeFunction);
if (xmlStrEqual(name, BAD_CAST "number"))
return(xmlXPathNumberFunction);
break;
case 'p':
if (xmlStrEqual(name, BAD_CAST "position"))
return(xmlXPathPositionFunction);
break;
case 'r':
if (xmlStrEqual(name, BAD_CAST "round"))
return(xmlXPathRoundFunction);
break;
case 's':
if (xmlStrEqual(name, BAD_CAST "string"))
return(xmlXPathStringFunction);
if (xmlStrEqual(name, BAD_CAST "string-length"))
return(xmlXPathStringLengthFunction);
if (xmlStrEqual(name, BAD_CAST "starts-with"))
return(xmlXPathStartsWithFunction);
if (xmlStrEqual(name, BAD_CAST "substring"))
return(xmlXPathSubstringFunction);
if (xmlStrEqual(name, BAD_CAST "substring-before"))
return(xmlXPathSubstringBeforeFunction);
if (xmlStrEqual(name, BAD_CAST "substring-after"))
return(xmlXPathSubstringAfterFunction);
if (xmlStrEqual(name, BAD_CAST "sum"))
return(xmlXPathSumFunction);
break;
case 't':
if (xmlStrEqual(name, BAD_CAST "true"))
return(xmlXPathTrueFunction);
if (xmlStrEqual(name, BAD_CAST "translate"))
return(xmlXPathTranslateFunction);
break;
}
return(xmlXPathFunctionLookup(ctxt->context, name));
} }
/** /**
@ -5383,4 +5268,65 @@ xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
return(res); return(res);
} }
void
xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
{
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean",
xmlXPathBooleanFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling",
xmlXPathCeilingFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count",
xmlXPathCountFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat",
xmlXPathConcatFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains",
xmlXPathContainsFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id",
xmlXPathIdFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false",
xmlXPathFalseFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor",
xmlXPathFloorFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last",
xmlXPathLastFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang",
xmlXPathLangFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-part",
xmlXPathLocalPartFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not",
xmlXPathNotFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name",
xmlXPathNameFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace",
xmlXPathNamespaceFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space",
xmlXPathNormalizeFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize",
xmlXPathNormalizeFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number",
xmlXPathNumberFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position",
xmlXPathPositionFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round",
xmlXPathRoundFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string",
xmlXPathStringFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length",
xmlXPathStringLengthFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with",
xmlXPathStartsWithFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring",
xmlXPathSubstringFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before",
xmlXPathSubstringBeforeFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after",
xmlXPathSubstringAfterFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum",
xmlXPathSumFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true",
xmlXPathTrueFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate",
xmlXPathTranslateFunction);
}
#endif /* LIBXML_XPATH_ENABLED */ #endif /* LIBXML_XPATH_ENABLED */

7
xpath.h
View File

@ -13,6 +13,7 @@
#define __XML_XPATH_H__ #define __XML_XPATH_H__
#include <libxml/tree.h> #include <libxml/tree.h>
#include <libxml/hash.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -184,9 +185,9 @@ struct _xmlXPathContext {
int max_types; /* max number of types */ int max_types; /* max number of types */
xmlXPathTypePtr types; /* Array of defined types */ xmlXPathTypePtr types; /* Array of defined types */
int nb_funcs; /* number of defined funcs */ int nb_funcs_unused; /* unused (hash table) */
int max_funcs; /* max number of funcs */ int max_funcs_unused; /* unused (hash table) */
xmlXPathFuncPtr funcs; /* Array of defined funcs */ xmlHashTablePtr funcHash; /* Hash table of defined funcs */
int nb_axis; /* number of defined axis */ int nb_axis; /* number of defined axis */
int max_axis; /* max number of axis */ int max_axis; /* max number of axis */