hash.c File Reference

#include "libxml.h"
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <libxml/parser.h>
#include <libxml/hash.h>
#include <libxml/xmlmemory.h>
#include <libxml/xmlerror.h>
#include <libxml/globals.h>

Include dependency graph for hash.c:

Go to the source code of this file.

Classes
struct	_xmlHashEntry
struct	_xmlHashTable
struct	stubData

Macros
#define	IN_LIBXML
#define	HASH_RANDOMIZATION
#define	MAX_HASH_LEN   8

Typedefs
typedef struct _xmlHashEntry	xmlHashEntry
typedef xmlHashEntry *	xmlHashEntryPtr

Functions
static unsigned long	xmlHashComputeKey (xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3)
static unsigned long	xmlHashComputeQKey (xmlHashTablePtr table, const xmlChar *prefix, const xmlChar *name, const xmlChar *prefix2, const xmlChar *name2, const xmlChar *prefix3, const xmlChar *name3)
xmlHashTablePtr	xmlHashCreate (int size)
xmlHashTablePtr	xmlHashCreateDict (int size, xmlDictPtr dict)
static int	xmlHashGrow (xmlHashTablePtr table, int size)
void	xmlHashFree (xmlHashTablePtr table, xmlHashDeallocator f)
: the entry's name
xmlHashDefaultDeallocator: @entry: the hash table entry Free a hash table entry with xmlFree.
void	xmlHashDefaultDeallocator (void *entry, const xmlChar *name ATTRIBUTE_UNUSED)
. Duplicate names generate errors.
Returns 0 the addition succeeded and -1 in case of error.
int	xmlHashAddEntry (xmlHashTablePtr table, const xmlChar *name, void *userdata)
, @name2) tuple. Duplicate tuples generate errors.
Returns 0 the addition succeeded and -1 in case of error.
int	xmlHashAddEntry2 (xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, void *userdata)
. Existing entry for this @name will be removed
and freed with @f if found. Returns 0 the addition succeeded and -1 in case of error.
int	xmlHashUpdateEntry (xmlHashTablePtr table, const xmlChar *name, void *userdata, xmlHashDeallocator f)
, @name2) tuple. Existing entry for this tuple will
be removed and freed with @f if found. Returns 0 the addition succeeded and -1 in case of error.
int	xmlHashUpdateEntry2 (xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, void *userdata, xmlHashDeallocator f)
.
Returns the pointer to the userdata
void *	xmlHashLookup (xmlHashTablePtr table, const xmlChar *name)
, @name2) tuple.
Returns the pointer to the userdata
void *	xmlHashLookup2 (xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2)
/@name.
Returns the pointer to the userdata
void *	xmlHashQLookup (xmlHashTablePtr table, const xmlChar *prefix, const xmlChar *name)
2: a second name of the userdata
void *	xmlHashQLookup2 (xmlHashTablePtr table, const xmlChar *prefix, const xmlChar *name, const xmlChar *prefix2, const xmlChar *name2)
, @name2, @name3). Duplicate entries generate
errors. Returns 0 the addition succeeded and -1 in case of error.
int	xmlHashAddEntry3 (xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, void *userdata)
, @name2, @name3). Existing entry for this tuple
will be removed and freed with @f if found. Returns 0 the addition succeeded and -1 in case of error.
int	xmlHashUpdateEntry3 (xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, void *userdata, xmlHashDeallocator f)
, @name2, @name3) tuple.
Returns the a pointer to the userdata
void *	xmlHashLookup3 (xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3)
void *	xmlHashQLookup3 (xmlHashTablePtr table, const xmlChar *prefix, const xmlChar *name, const xmlChar *prefix2, const xmlChar *name2, const xmlChar *prefix3, const xmlChar *name3)
static void	stubHashScannerFull (void *payload, void *data, const xmlChar *name, const xmlChar *name2 ATTRIBUTE_UNUSED, const xmlChar *name3 ATTRIBUTE_UNUSED)
void	xmlHashScan (xmlHashTablePtr table, xmlHashScanner f, void *data)
void	xmlHashScanFull (xmlHashTablePtr table, xmlHashScannerFull f, void *data)
, @name2, @name3) tuple. If one of the names is null,
the comparison is considered to match.
void	xmlHashScan3 (xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, xmlHashScanner f, void *data)
void	xmlHashScanFull3 (xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, xmlHashScannerFull f, void *data)
xmlHashTablePtr	xmlHashCopy (xmlHashTablePtr table, xmlHashCopier f)
int	xmlHashSize (xmlHashTablePtr table)
and remove
it from the hash @table. Existing userdata for this tuple will be removed and freed with @f. Returns 0 if the removal succeeded and -1 in case of error or not found.
int	xmlHashRemoveEntry (xmlHashTablePtr table, const xmlChar *name, xmlHashDeallocator f)
, @name2) tuple and remove
it from the hash @table. Existing userdata for this tuple will be removed and freed with @f. Returns 0 if the removal succeeded and -1 in case of error or not found.
int	xmlHashRemoveEntry2 (xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, xmlHashDeallocator f)
, @name2, @name3) tuple and remove
it from the hash @table. Existing userdata for this tuple will be removed and freed with @f. Returns 0 if the removal succeeded and -1 in case of error or not found.
int	xmlHashRemoveEntry3 (xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, xmlHashDeallocator f)

Macro Definition Documentation

HASH_RANDOMIZATION

#define HASH_RANDOMIZATION

Definition at line 33 of file hash.c.

IN_LIBXML

#define IN_LIBXML

Definition at line 20 of file hash.c.

MAX_HASH_LEN

#define MAX_HASH_LEN   8

Definition at line 42 of file hash.c.

Typedef Documentation

xmlHashEntry

typedef struct _xmlHashEntry xmlHashEntry

Definition at line 49 of file hash.c.

xmlHashEntryPtr

typedef xmlHashEntry* xmlHashEntryPtr

Definition at line 50 of file hash.c.

Function Documentation

stubHashScannerFull()

static void stubHashScannerFull ( void *  payload, void *  data, const xmlChar *  name, const xmlChar *name2  ATTRIBUTE_UNUSED, const xmlChar *name3  ATTRIBUTE_UNUSED  )

static

Definition at line 843 of file hash.c.

                                                    {
    stubData *stubdata = (stubData *) data;
    stubdata->hashscanner (payload, stubdata->data, (xmlChar *) name);
}

Referenced by xmlHashScan(), and xmlHashScan3().

xmlHashAddEntry()

int xmlHashAddEntry	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		void *	userdata
	)

Definition at line 389 of file hash.c.

                                                                            {
    return(xmlHashAddEntry3(table, name, NULL, NULL, userdata));
}

Referenced by xmlAddID(), xmlAddNotationDecl(), xmlAddRef(), xsltGetExtData(), xsltInitCtxtExt(), xsltInitCtxtKey(), xsltNamespaceAlias(), xsltRegisterExtModuleFull(), and xsltStyleInitializeStylesheetModule().

xmlHashAddEntry2()

int xmlHashAddEntry2	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		const xmlChar *	name2,
		void *	userdata
	)

Definition at line 406 of file hash.c.

                                                  {
    return(xmlHashAddEntry3(table, name, name2, NULL, userdata));
}

Referenced by xmlAddElementDecl(), xmlAddSpecialAttr(), xmlGetDtdElementDesc2(), xsltAddTemplate(), xsltDocumentElem(), xsltEvalGlobalVariables(), xsltParseStylesheetAttributeSet(), xsltParseStylesheetOutput(), xsltParseStylesheetPreserveSpace(), xsltParseStylesheetStripSpace(), xsltProcessUserParamInternal(), xsltRegisterExtElement(), xsltRegisterExtFunction(), and xsltResolveSASCallback().

xmlHashAddEntry3()

int xmlHashAddEntry3	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		const xmlChar *	name2,
		const xmlChar *	name3,
		void *	userdata
	)

Definition at line 531 of file hash.c.

                         {
    unsigned long key, len = 0;
    xmlHashEntryPtr entry;
    xmlHashEntryPtr insert;
 
    if ((table == NULL) || (name == NULL))
    return(-1);
 
    /*
     * If using a dict internalize if needed
     */
    if (table->dict) {
        if (!xmlDictOwns(table->dict, name)) {
        name = xmlDictLookup(table->dict, name, -1);
        if (name == NULL)
            return(-1);
    }
        if ((name2 != NULL) && (!xmlDictOwns(table->dict, name2))) {
        name2 = xmlDictLookup(table->dict, name2, -1);
        if (name2 == NULL)
            return(-1);
    }
        if ((name3 != NULL) && (!xmlDictOwns(table->dict, name3))) {
        name3 = xmlDictLookup(table->dict, name3, -1);
        if (name3 == NULL)
            return(-1);
    }
    }
 
    /*
     * Check for duplicate and insertion location.
     */
    key = xmlHashComputeKey(table, name, name2, name3);
    if (table->table[key].valid == 0) {
    insert = NULL;
    } else {
        if (table->dict) {
        for (insert = &(table->table[key]); insert->next != NULL;
         insert = insert->next) {
        if ((insert->name == name) &&
            (insert->name2 == name2) &&
            (insert->name3 == name3))
            return(-1);
        len++;
        }
        if ((insert->name == name) &&
        (insert->name2 == name2) &&
        (insert->name3 == name3))
        return(-1);
    } else {
        for (insert = &(table->table[key]); insert->next != NULL;
         insert = insert->next) {
        if ((xmlStrEqual(insert->name, name)) &&
            (xmlStrEqual(insert->name2, name2)) &&
            (xmlStrEqual(insert->name3, name3)))
            return(-1);
        len++;
        }
        if ((xmlStrEqual(insert->name, name)) &&
        (xmlStrEqual(insert->name2, name2)) &&
        (xmlStrEqual(insert->name3, name3)))
        return(-1);
    }
    }
 
    if (insert == NULL) {
    entry = &(table->table[key]);
    } else {
    entry = xmlMalloc(sizeof(xmlHashEntry));
    if (entry == NULL)
         return(-1);
    }
 
    if (table->dict != NULL) {
        entry->name = (xmlChar *) name;
        entry->name2 = (xmlChar *) name2;
        entry->name3 = (xmlChar *) name3;
    } else {
    entry->name = xmlStrdup(name);
    entry->name2 = xmlStrdup(name2);
    entry->name3 = xmlStrdup(name3);
    }
    entry->payload = userdata;
    entry->next = NULL;
    entry->valid = 1;
 
 
    if (insert != NULL)
    insert->next = entry;
 
    table->nbElems++;
 
    if (len > MAX_HASH_LEN)
    xmlHashGrow(table, MAX_HASH_LEN * table->size);
 
    return(0);
}

Referenced by xmlAddAttributeDecl(), xmlHashAddEntry(), xmlHashAddEntry2(), xmlHashCopy(), and xsltAddTemplate().

xmlHashComputeKey()

static unsigned long xmlHashComputeKey ( xmlHashTablePtr  table, const xmlChar *  name, const xmlChar *  name2, const xmlChar *  name3  )

static

Definition at line 81 of file hash.c.

                                                          {
    unsigned long value = 0L;
    unsigned long ch;
 
#ifdef HASH_RANDOMIZATION
    value = table->random_seed;
#endif
    if (name != NULL) {
    value += 30 * (*name);
    while ((ch = *name++) != 0) {
        value = value ^ ((value << 5) + (value >> 3) + ch);
    }
    }
    value = value ^ ((value << 5) + (value >> 3));
    if (name2 != NULL) {
    while ((ch = *name2++) != 0) {
        value = value ^ ((value << 5) + (value >> 3) + ch);
    }
    }
    value = value ^ ((value << 5) + (value >> 3));
    if (name3 != NULL) {
    while ((ch = *name3++) != 0) {
        value = value ^ ((value << 5) + (value >> 3) + ch);
    }
    }
    return (value % table->size);
}

Referenced by xmlHashAddEntry3(), xmlHashGrow(), xmlHashLookup3(), xmlHashRemoveEntry3(), and xmlHashUpdateEntry3().

xmlHashComputeQKey()

static unsigned long xmlHashComputeQKey ( xmlHashTablePtr  table, const xmlChar *  prefix, const xmlChar *  name, const xmlChar *  prefix2, const xmlChar *  name2, const xmlChar *  prefix3, const xmlChar *  name3  )

static

Definition at line 114 of file hash.c.

                                                         {
    unsigned long value = 0L;
    unsigned long ch;
 
#ifdef HASH_RANDOMIZATION
    value = table->random_seed;
#endif
    if (prefix != NULL)
    value += 30 * (*prefix);
    else
    value += 30 * (*name);
 
    if (prefix != NULL) {
    while ((ch = *prefix++) != 0) {
        value = value ^ ((value << 5) + (value >> 3) + ch);
    }
    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)':');
    }
    if (name != NULL) {
    while ((ch = *name++) != 0) {
        value = value ^ ((value << 5) + (value >> 3) + ch);
    }
    }
    value = value ^ ((value << 5) + (value >> 3));
    if (prefix2 != NULL) {
    while ((ch = *prefix2++) != 0) {
        value = value ^ ((value << 5) + (value >> 3) + ch);
    }
    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)':');
    }
    if (name2 != NULL) {
    while ((ch = *name2++) != 0) {
        value = value ^ ((value << 5) + (value >> 3) + ch);
    }
    }
    value = value ^ ((value << 5) + (value >> 3));
    if (prefix3 != NULL) {
    while ((ch = *prefix3++) != 0) {
        value = value ^ ((value << 5) + (value >> 3) + ch);
    }
    value = value ^ ((value << 5) + (value >> 3) + (unsigned long)':');
    }
    if (name3 != NULL) {
    while ((ch = *name3++) != 0) {
        value = value ^ ((value << 5) + (value >> 3) + ch);
    }
    }
    return (value % table->size);
}

Referenced by xmlHashQLookup3().

xmlHashCopy()

xmlHashTablePtr xmlHashCopy	(	xmlHashTablePtr	table,
		xmlHashCopier	f
	)

xmlHashCopy: @table: the hash table @f: the copier function for items in the hash

Scan the hash @table and applied @f to each value.

Returns the new table or NULL in case of error.

Definition at line 992 of file hash.c.

                                                    {
    int i;
    xmlHashEntryPtr iter;
    xmlHashEntryPtr next;
    xmlHashTablePtr ret;
 
    if (table == NULL)
    return(NULL);
    if (f == NULL)
    return(NULL);
 
    ret = xmlHashCreate(table->size);
    if (ret == NULL)
        return(NULL);
 
    if (table->table) {
    for(i = 0; i < table->size; i++) {
        if (table->table[i].valid == 0)
        continue;
        iter = &(table->table[i]);
        while (iter) {
        next = iter->next;
        xmlHashAddEntry3(ret, iter->name, iter->name2,
                     iter->name3, f(iter->payload, iter->name));
        iter = next;
        }
    }
    }
    ret->nbElems = table->nbElems;
    return(ret);
}

xmlHashCreate()

xmlHashTablePtr xmlHashCreate

(

int

size

)

xmlHashCreate: @size: the size of the hash table

Create a new xmlHashTablePtr.

Returns the newly created object, or NULL if an error occurred.

Definition at line 176 of file hash.c.

                        {
    xmlHashTablePtr table;
 
    if (size <= 0)
        size = 256;
 
    table = xmlMalloc(sizeof(xmlHashTable));
    if (table) {
        table->dict = NULL;
        table->size = size;
    table->nbElems = 0;
        table->table = xmlMalloc(size * sizeof(xmlHashEntry));
        if (table->table) {
        memset(table->table, 0, size * sizeof(xmlHashEntry));
#ifdef HASH_RANDOMIZATION
            table->random_seed = __xmlRandom();
#endif
        return(table);
        }
        xmlFree(table);
    }
    return(NULL);
}

Referenced by xmlHashCopy(), xmlHashCreateDict(), xsltAddTemplate(), xsltApplyStylesheetInternal(), xsltDocumentElem(), xsltGatherNamespaces(), xsltGetExtData(), xsltInitCtxtExt(), xsltNamespaceAlias(), xsltNewKeyTable(), xsltParseStylesheetAttributeSet(), xsltParseStylesheetOutput(), xsltParseStylesheetPreserveSpace(), xsltParseStylesheetStripSpace(), xsltProcessUserParamInternal(), xsltRegisterExtElement(), xsltRegisterExtFunction(), xsltRegisterExtModuleElement(), xsltRegisterExtModuleFull(), xsltRegisterExtModuleFunction(), xsltRegisterExtModuleTopLevel(), xsltResolveStylesheetAttributeSet(), and xsltStyleInitializeStylesheetModule().

xmlHashCreateDict()

xmlHashTablePtr xmlHashCreateDict	(	int	size,
		xmlDictPtr	dict
	)

xmlHashCreateDict: @size: the size of the hash table @dict: a dictionary to use for the hash

Create a new xmlHashTablePtr which will use @dict as the internal dictionary

Returns the newly created object, or NULL if an error occurred.

Definition at line 210 of file hash.c.

                                             {
    xmlHashTablePtr table;
 
    table = xmlHashCreate(size);
    if (table != NULL) {
        table->dict = dict;
    xmlDictReference(dict);
    }
    return(table);
}

Referenced by xmlAddAttributeDecl(), xmlAddDefAttrs(), xmlAddElementDecl(), xmlAddID(), xmlAddNotationDecl(), xmlAddRef(), xmlAddSpecialAttr(), and xmlGetDtdElementDesc2().

xmlHashDefaultDeallocator()

void xmlHashDefaultDeallocator	(	void *	entry,
		const xmlChar *name	ATTRIBUTE_UNUSED
	)

Definition at line 373 of file hash.c.

                                                                             {
    xmlFree(entry);
}

xmlHashFree()

void xmlHashFree	(	xmlHashTablePtr	table,
		xmlHashDeallocator	f
	)

xmlHashFree: @table: the hash table @f: the deallocator function for items in the hash

Free the hash @table and its contents. The userdata is deallocated with @f if provided.

Definition at line 322 of file hash.c.

                                                         {
    int i;
    xmlHashEntryPtr iter;
    xmlHashEntryPtr next;
    int inside_table = 0;
    int nbElems;
 
    if (table == NULL)
    return;
    if (table->table) {
    nbElems = table->nbElems;
    for(i = 0; (i < table->size) && (nbElems > 0); i++) {
        iter = &(table->table[i]);
        if (iter->valid == 0)
        continue;
        inside_table = 1;
        while (iter) {
        next = iter->next;
        if ((f != NULL) && (iter->payload != NULL))
            f(iter->payload, iter->name);
        if (table->dict == NULL) {
            if (iter->name)
            xmlFree(iter->name);
            if (iter->name2)
            xmlFree(iter->name2);
            if (iter->name3)
            xmlFree(iter->name3);
        }
        iter->payload = NULL;
        if (!inside_table)
            xmlFree(iter);
        nbElems--;
        inside_table = 0;
        iter = next;
        }
    }
    xmlFree(table->table);
    }
    if (table->dict)
        xmlDictFree(table->dict);
    xmlFree(table);
}

Referenced by xmlCleanSpecialAttr(), xmlCtxtReset(), xmlFreeAttributeTable(), xmlFreeElementTable(), xmlFreeIDTable(), xmlFreeNotationTable(), xmlFreeParserCtxt(), xmlFreeRefTable(), xsltCleanupGlobals(), xsltFreeAttributeSetsHashes(), xsltFreeCtxtExts(), xsltFreeGlobalVariables(), xsltFreeKeyTable(), xsltFreeNamespaceAliasHashes(), xsltFreeStylesheet(), xsltFreeTemplateHashes(), xsltResolveStylesheetAttributeSet(), xsltShutdownCtxtExts(), xsltShutdownExts(), xsltUnregisterAllExtModuleElement(), xsltUnregisterAllExtModuleFunction(), xsltUnregisterAllExtModules(), and xsltUnregisterAllExtModuleTopLevel().

xmlHashGrow()

static int xmlHashGrow ( xmlHashTablePtr  table, int  size  )

static

xmlHashGrow: @table: the hash table @size: the new size of the hash table

resize the hash table

Returns 0 in case of success, -1 in case of failure

Definition at line 231 of file hash.c.

                                             {
    unsigned long key;
    int oldsize, i;
    xmlHashEntryPtr iter, next;
    struct _xmlHashEntry *oldtable;
#ifdef DEBUG_GROW
    unsigned long nbElem = 0;
#endif
 
    if (table == NULL)
    return(-1);
    if (size < 8)
        return(-1);
    if (size > 8 * 2048)
    return(-1);
 
    oldsize = table->size;
    oldtable = table->table;
    if (oldtable == NULL)
        return(-1);
 
    table->table = xmlMalloc(size * sizeof(xmlHashEntry));
    if (table->table == NULL) {
    table->table = oldtable;
    return(-1);
    }
    memset(table->table, 0, size * sizeof(xmlHashEntry));
    table->size = size;
 
    /*  If the two loops are merged, there would be situations where
    a new entry needs to allocated and data copied into it from
    the main table. So instead, we run through the array twice, first
    copying all the elements in the main array (where we can't get
    conflicts) and then the rest, so we only free (and don't allocate)
    */
    for (i = 0; i < oldsize; i++) {
    if (oldtable[i].valid == 0)
        continue;
    key = xmlHashComputeKey(table, oldtable[i].name, oldtable[i].name2,
                oldtable[i].name3);
    memcpy(&(table->table[key]), &(oldtable[i]), sizeof(xmlHashEntry));
    table->table[key].next = NULL;
    }
 
    for (i = 0; i < oldsize; i++) {
    iter = oldtable[i].next;
    while (iter) {
        next = iter->next;
 
        /*
         * put back the entry in the new table
         */
 
        key = xmlHashComputeKey(table, iter->name, iter->name2,
                            iter->name3);
        if (table->table[key].valid == 0) {
        memcpy(&(table->table[key]), iter, sizeof(xmlHashEntry));
        table->table[key].next = NULL;
        xmlFree(iter);
        } else {
        iter->next = table->table[key].next;
        table->table[key].next = iter;
        }
 
#ifdef DEBUG_GROW
        nbElem++;
#endif
 
        iter = next;
    }
    }
 
    xmlFree(oldtable);
 
#ifdef DEBUG_GROW
    xmlGenericError(xmlGenericErrorContext,
        "xmlHashGrow : from %d to %d, %d elems\n", oldsize, size, nbElem);
#endif
 
    return(0);
}

Referenced by xmlHashAddEntry3().

xmlHashLookup()

void * xmlHashLookup	(	xmlHashTablePtr	table,
		const xmlChar *	name
	)

Definition at line 461 of file hash.c.

                                                          {
    return(xmlHashLookup3(table, name, NULL, NULL));
}

Referenced by xmlAddRef(), xmlGetDtdNotationDesc(), xmlGetID(), xmlGetRefs(), xmlRemoveID(), xmlRemoveRef(), xsltApplySequenceConstructor(), xsltCheckInstructionElement(), xsltCheckParentElement(), xsltCopyNamespaceList(), xsltGatherNamespaces(), xsltGetExtData(), xsltGetExtInfo(), xsltGetKey(), xsltGetNamespace(), xsltInitCtxtExt(), xsltInitCtxtKey(), xsltRegisterExtModuleFull(), xsltRegisterExtPrefix(), xsltStyleGetExtData(), and xsltStyleInitializeStylesheetModule().

xmlHashLookup2()

void * xmlHashLookup2	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		const xmlChar *	name2
	)

Definition at line 476 of file hash.c.

                                {
    return(xmlHashLookup3(table, name, name2, NULL));
}

Referenced by xmlAddDefAttrs(), xmlAddElementDecl(), xmlAddSpecialAttr(), xmlGetDtdElementDesc(), xmlGetDtdElementDesc2(), xmlGetDtdQElementDesc(), xmlParseStartTag2(), xsltAddTemplate(), xsltApplyAttributeSet(), xsltCopyText(), xsltCopyTextString(), xsltEvalGlobalVariables(), xsltExtElementLookup(), xsltExtModuleElementLookup(), xsltExtModuleElementPreComputeLookup(), xsltExtModuleFunctionLookup(), xsltExtModuleTopLevelLookup(), xsltFindElemSpaceHandling(), xsltFindTemplate(), xsltGlobalVariableLookup(), xsltParseStylesheetAttributeSet(), xsltPreComputeExtModuleElement(), xsltProcessUserParamInternal(), xsltResolveAttrSet(), xsltResolveUseAttrSets(), and xsltXPathFunctionLookup().

xmlHashLookup3()

void * xmlHashLookup3	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		const xmlChar *	name2,
		const xmlChar *	name3
	)

Definition at line 769 of file hash.c.

                                                       {
    unsigned long key;
    xmlHashEntryPtr entry;
 
    if (table == NULL)
    return(NULL);
    if (name == NULL)
    return(NULL);
    key = xmlHashComputeKey(table, name, name2, name3);
    if (table->table[key].valid == 0)
    return(NULL);
    if (table->dict) {
    for (entry = &(table->table[key]); entry != NULL; entry = entry->next) {
        if ((entry->name == name) &&
        (entry->name2 == name2) &&
        (entry->name3 == name3))
        return(entry->payload);
    }
    }
    for (entry = &(table->table[key]); entry != NULL; entry = entry->next) {
    if ((xmlStrEqual(entry->name, name)) &&
        (xmlStrEqual(entry->name2, name2)) &&
        (xmlStrEqual(entry->name3, name3)))
        return(entry->payload);
    }
    return(NULL);
}

Referenced by xmlAddAttributeDecl(), xmlGetDtdAttrDesc(), xmlGetDtdQAttrDesc(), xmlHashLookup(), xmlHashLookup2(), xsltAddTemplate(), and xsltGetTemplate().

xmlHashQLookup()

void * xmlHashQLookup	(	xmlHashTablePtr	table,
		const xmlChar *	prefix,
		const xmlChar *	name
	)

Definition at line 492 of file hash.c.

                                    {
    return(xmlHashQLookup3(table, prefix, name, NULL, NULL, NULL, NULL));
}

xmlHashQLookup2()

void * xmlHashQLookup2	(	xmlHashTablePtr	table,
		const xmlChar *	prefix,
		const xmlChar *	name,
		const xmlChar *	prefix2,
		const xmlChar *	name2
	)

Definition at line 510 of file hash.c.

                                  {
    return(xmlHashQLookup3(table, prefix, name, prefix2, name2, NULL, NULL));
}

Referenced by xmlParseAttribute2().

xmlHashQLookup3()

void * xmlHashQLookup3	(	xmlHashTablePtr	table,
		const xmlChar *	prefix,
		const xmlChar *	name,
		const xmlChar *	prefix2,
		const xmlChar *	name2,
		const xmlChar *	prefix3,
		const xmlChar *	name3
	)

Definition at line 813 of file hash.c.

                                                      {
    unsigned long key;
    xmlHashEntryPtr entry;
 
    if (table == NULL)
    return(NULL);
    if (name == NULL)
    return(NULL);
    key = xmlHashComputeQKey(table, prefix, name, prefix2,
                             name2, prefix3, name3);
    if (table->table[key].valid == 0)
    return(NULL);
    for (entry = &(table->table[key]); entry != NULL; entry = entry->next) {
    if ((xmlStrQEqual(prefix, name, entry->name)) &&
        (xmlStrQEqual(prefix2, name2, entry->name2)) &&
        (xmlStrQEqual(prefix3, name3, entry->name3)))
        return(entry->payload);
    }
    return(NULL);
}

Referenced by xmlHashQLookup(), and xmlHashQLookup2().

xmlHashRemoveEntry()

int xmlHashRemoveEntry	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		xmlHashDeallocator	f
	)

Definition at line 1052 of file hash.c.

                                     {
    return(xmlHashRemoveEntry3(table, name, NULL, NULL, f));
}

Referenced by xmlRemoveID(), and xsltUnregisterExtModule().

xmlHashRemoveEntry2()

int xmlHashRemoveEntry2	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		const xmlChar *	name2,
		xmlHashDeallocator	f
	)

Definition at line 1071 of file hash.c.

                                                        {
    return(xmlHashRemoveEntry3(table, name, name2, NULL, f));
}

Referenced by xmlAddElementDecl(), xmlCleanSpecialAttrCallback(), xsltResolveAttrSet(), xsltUnregisterExtModuleElement(), xsltUnregisterExtModuleFunction(), and xsltUnregisterExtModuleTopLevel().

xmlHashRemoveEntry3()

int xmlHashRemoveEntry3	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		const xmlChar *	name2,
		const xmlChar *	name3,
		xmlHashDeallocator	f
	)

Definition at line 1091 of file hash.c.

                                                                      {
    unsigned long key;
    xmlHashEntryPtr entry;
    xmlHashEntryPtr prev = NULL;
 
    if (table == NULL || name == NULL)
        return(-1);
 
    key = xmlHashComputeKey(table, name, name2, name3);
    if (table->table[key].valid == 0) {
        return(-1);
    } else {
        for (entry = &(table->table[key]); entry != NULL; entry = entry->next) {
            if (xmlStrEqual(entry->name, name) &&
                    xmlStrEqual(entry->name2, name2) &&
                    xmlStrEqual(entry->name3, name3)) {
                if ((f != NULL) && (entry->payload != NULL))
                    f(entry->payload, entry->name);
                entry->payload = NULL;
        if (table->dict == NULL) {
            if(entry->name)
            xmlFree(entry->name);
            if(entry->name2)
            xmlFree(entry->name2);
            if(entry->name3)
            xmlFree(entry->name3);
        }
                if(prev) {
                    prev->next = entry->next;
            xmlFree(entry);
        } else {
            if (entry->next == NULL) {
            entry->valid = 0;
            } else {
            entry = entry->next;
            memcpy(&(table->table[key]), entry, sizeof(xmlHashEntry));
            xmlFree(entry);
            }
        }
                table->nbElems--;
                return(0);
            }
            prev = entry;
        }
        return(-1);
    }
}

Referenced by xmlHashRemoveEntry(), and xmlHashRemoveEntry2().

xmlHashScan()

void xmlHashScan	(	xmlHashTablePtr	table,
		xmlHashScanner	f,
		void *	data
	)

xmlHashScan: @table: the hash table @f: the scanner function for items in the hash @data: extra data passed to f

Scan the hash @table and applied @f to each value.

Definition at line 859 of file hash.c.

                                                                 {
    stubData stubdata;
    stubdata.data = data;
    stubdata.hashscanner = f;
    xmlHashScanFull (table, stubHashScannerFull, &stubdata);
}

Referenced by xsltCleanupGlobals(), xsltEvalGlobalVariables(), xsltFixImportedCompSteps(), xsltInitCtxtExts(), xsltShutdownCtxtExts(), and xsltShutdownExts().

xmlHashScan3()

void xmlHashScan3	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		const xmlChar *	name2,
		const xmlChar *	name3,
		xmlHashScanner	f,
		void *	data
	)

Definition at line 926 of file hash.c.

                                       {
    stubData stubdata;
    stubdata.data = data;
    stubdata.hashscanner = f;
    xmlHashScanFull3(table, name, name2, name3, stubHashScannerFull,
                     &stubdata);
}

xmlHashScanFull()

void xmlHashScanFull	(	xmlHashTablePtr	table,
		xmlHashScannerFull	f,
		void *	data
	)

xmlHashScanFull: @table: the hash table @f: the scanner function for items in the hash @data: extra data passed to f

Scan the hash @table and applied @f to each value.

Definition at line 875 of file hash.c.

                                                                         {
    int i, nb;
    xmlHashEntryPtr iter;
    xmlHashEntryPtr next;
 
    if (table == NULL)
    return;
    if (f == NULL)
    return;
 
    if (table->table) {
    for(i = 0; i < table->size; i++) {
        if (table->table[i].valid == 0)
        continue;
        iter = &(table->table[i]);
        while (iter) {
        next = iter->next;
                nb = table->nbElems;
        if ((f != NULL) && (iter->payload != NULL))
            f(iter->payload, data, iter->name,
              iter->name2, iter->name3);
                if (nb != table->nbElems) {
                    /* table was modified by the callback, be careful */
                    if (iter == &(table->table[i])) {
                        if (table->table[i].valid == 0)
                            iter = NULL;
                        if (table->table[i].next != next)
                iter = &(table->table[i]);
                    } else
                iter = next;
                } else
            iter = next;
        }
    }
    }
}

Referenced by xmlCleanSpecialAttr(), xmlHashScan(), xsltDebugDumpExtensions(), and xsltResolveStylesheetAttributeSet().

xmlHashScanFull3()

void xmlHashScanFull3	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		const xmlChar *	name2,
		const xmlChar *	name3,
		xmlHashScannerFull	f,
		void *	data
	)

Definition at line 950 of file hash.c.

                                           {
    int i;
    xmlHashEntryPtr iter;
    xmlHashEntryPtr next;
 
    if (table == NULL)
    return;
    if (f == NULL)
    return;
 
    if (table->table) {
    for(i = 0; i < table->size; i++) {
        if (table->table[i].valid == 0)
        continue;
        iter = &(table->table[i]);
        while (iter) {
        next = iter->next;
        if (((name == NULL) || (xmlStrEqual(name, iter->name))) &&
            ((name2 == NULL) || (xmlStrEqual(name2, iter->name2))) &&
            ((name3 == NULL) || (xmlStrEqual(name3, iter->name3))) &&
            (iter->payload != NULL)) {
            f(iter->payload, data, iter->name,
              iter->name2, iter->name3);
        }
        iter = next;
        }
    }
    }
}

Referenced by xmlHashScan3().

xmlHashSize()

int xmlHashSize

(

xmlHashTablePtr

table

)

xmlHashSize: @table: the hash table

Query the number of elements installed in the hash @table.

Returns the number of elements in the hash table or -1 in case of error

Definition at line 1034 of file hash.c.

                                   {
    if (table == NULL)
    return(-1);
    return(table->nbElems);
}

Referenced by xmlCleanSpecialAttr().

xmlHashUpdateEntry()

int xmlHashUpdateEntry	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		void *	userdata,
		xmlHashDeallocator	f
	)

Definition at line 425 of file hash.c.

                                                     {
    return(xmlHashUpdateEntry3(table, name, NULL, NULL, userdata, f));
}

Referenced by xmlRemoveRef(), and xsltGatherNamespaces().

xmlHashUpdateEntry2()

int xmlHashUpdateEntry2	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		const xmlChar *	name2,
		void *	userdata,
		xmlHashDeallocator	f
	)

Definition at line 445 of file hash.c.

                                 {
    return(xmlHashUpdateEntry3(table, name, name2, NULL, userdata, f));
}

Referenced by xmlAddDefAttrs(), xsltRegisterExtModuleElement(), xsltRegisterExtModuleFunction(), and xsltRegisterExtModuleTopLevel().

xmlHashUpdateEntry3()

int xmlHashUpdateEntry3	(	xmlHashTablePtr	table,
		const xmlChar *	name,
		const xmlChar *	name2,
		const xmlChar *	name3,
		void *	userdata,
		xmlHashDeallocator	f
	)

Definition at line 647 of file hash.c.

                                                 {
    unsigned long key;
    xmlHashEntryPtr entry;
    xmlHashEntryPtr insert;
 
    if ((table == NULL) || name == NULL)
    return(-1);
 
    /*
     * If using a dict internalize if needed
     */
    if (table->dict) {
        if (!xmlDictOwns(table->dict, name)) {
        name = xmlDictLookup(table->dict, name, -1);
        if (name == NULL)
            return(-1);
    }
        if ((name2 != NULL) && (!xmlDictOwns(table->dict, name2))) {
        name2 = xmlDictLookup(table->dict, name2, -1);
        if (name2 == NULL)
            return(-1);
    }
        if ((name3 != NULL) && (!xmlDictOwns(table->dict, name3))) {
        name3 = xmlDictLookup(table->dict, name3, -1);
        if (name3 == NULL)
            return(-1);
    }
    }
 
    /*
     * Check for duplicate and insertion location.
     */
    key = xmlHashComputeKey(table, name, name2, name3);
    if (table->table[key].valid == 0) {
    insert = NULL;
    } else {
        if (table ->dict) {
        for (insert = &(table->table[key]); insert->next != NULL;
         insert = insert->next) {
        if ((insert->name == name) &&
            (insert->name2 == name2) &&
            (insert->name3 == name3)) {
            if (f)
            f(insert->payload, insert->name);
            insert->payload = userdata;
            return(0);
        }
        }
        if ((insert->name == name) &&
        (insert->name2 == name2) &&
        (insert->name3 == name3)) {
        if (f)
            f(insert->payload, insert->name);
        insert->payload = userdata;
        return(0);
        }
    } else {
        for (insert = &(table->table[key]); insert->next != NULL;
         insert = insert->next) {
        if ((xmlStrEqual(insert->name, name)) &&
            (xmlStrEqual(insert->name2, name2)) &&
            (xmlStrEqual(insert->name3, name3))) {
            if (f)
            f(insert->payload, insert->name);
            insert->payload = userdata;
            return(0);
        }
        }
        if ((xmlStrEqual(insert->name, name)) &&
        (xmlStrEqual(insert->name2, name2)) &&
        (xmlStrEqual(insert->name3, name3))) {
        if (f)
            f(insert->payload, insert->name);
        insert->payload = userdata;
        return(0);
        }
    }
    }
 
    if (insert == NULL) {
    entry =  &(table->table[key]);
    } else {
    entry = xmlMalloc(sizeof(xmlHashEntry));
    if (entry == NULL)
         return(-1);
    }
 
    if (table->dict != NULL) {
        entry->name = (xmlChar *) name;
        entry->name2 = (xmlChar *) name2;
        entry->name3 = (xmlChar *) name3;
    } else {
    entry->name = xmlStrdup(name);
    entry->name2 = xmlStrdup(name2);
    entry->name3 = xmlStrdup(name3);
    }
    entry->payload = userdata;
    entry->next = NULL;
    entry->valid = 1;
    table->nbElems++;
 
 
    if (insert != NULL) {
    insert->next = entry;
    }
    return(0);
}

Referenced by xmlHashUpdateEntry(), xmlHashUpdateEntry2(), and xsltAddTemplate().