dict.h File Reference

#include <limits.h>
#include <libxml/xmlversion.h>
#include <libxml/tree.h>

Include dependency graph for dict.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	__XML_EXTERNC

Typedefs
typedef typedef__XML_EXTERNC struct _xmlDict	xmlDict

Functions
XMLPUBFUN int XMLCALL	xmlInitializeDict (void)
XMLPUBFUN xmlDictPtr XMLCALL	xmlDictCreate (void)
XMLPUBFUN size_t XMLCALL	xmlDictSetLimit (xmlDictPtr dict, size_t limit)
XMLPUBFUN size_t XMLCALL	xmlDictGetUsage (xmlDictPtr dict)
XMLPUBFUN xmlDictPtr XMLCALL	xmlDictCreateSub (xmlDictPtr sub)
XMLPUBFUN int XMLCALL	xmlDictReference (xmlDictPtr dict)
XMLPUBFUN void XMLCALL	xmlDictFree (xmlDictPtr dict)
XMLPUBFUN const xmlChar *XMLCALL	xmlDictLookup (xmlDictPtr dict, const xmlChar *name, int len)
XMLPUBFUN const xmlChar *XMLCALL	xmlDictExists (xmlDictPtr dict, const xmlChar *name, int len)
XMLPUBFUN const xmlChar *XMLCALL	xmlDictQLookup (xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name)
XMLPUBFUN int XMLCALL	xmlDictOwns (xmlDictPtr dict, const xmlChar *str)
XMLPUBFUN int XMLCALL	xmlDictSize (xmlDictPtr dict)
XMLPUBFUN void XMLCALL	xmlDictCleanup (void)

Variables
__XML_EXTERNC typedef xmlDict *	xmlDictPtr

Macro Definition Documentation

__XML_EXTERNC

#define __XML_EXTERNC

Definition at line 17 of file dict.h.

Typedef Documentation

xmlDict

typedef typedef__XML_EXTERNC struct _xmlDict xmlDict

Definition at line 23 of file dict.h.

Function Documentation

xmlDictCleanup()

XMLPUBFUN void XMLCALL xmlDictCleanup

(

void

)

xmlDictCleanup:

Free the dictionary mutex. Do not call unless sure the library is not in use anymore !

Definition at line 221 of file dict.c.

                     {
    if (!xmlDictInitialized)
        return;

    xmlFreeRMutex(xmlDictMutex);

    xmlDictInitialized = 0;
}

Referenced by xmlCleanupParser().

xmlDictCreate()

XMLPUBFUN xmlDictPtr XMLCALL xmlDictCreate

(

void

)

xmlDictCreate:

Create a new dictionary

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

Definition at line 568 of file dict.c.

                    {
    xmlDictPtr dict;

    if (!xmlDictInitialized)
        if (!__xmlInitializeDict())
            return(NULL);

#ifdef DICT_DEBUG_PATTERNS
    fprintf(stderr, "C");
#endif

    dict = xmlMalloc(sizeof(xmlDict));
    if (dict) {
        dict->ref_counter = 1;
        dict->limit = 0;

        dict->size = MIN_DICT_SIZE;
    dict->nbElems = 0;
        dict->dict = xmlMalloc(MIN_DICT_SIZE * sizeof(xmlDictEntry));
    dict->strings = NULL;
    dict->subdict = NULL;
        if (dict->dict) {
        memset(dict->dict, 0, MIN_DICT_SIZE * sizeof(xmlDictEntry));
#ifdef DICT_RANDOMIZATION
            dict->seed = __xmlRandom();
#else
            dict->seed = 0;
#endif
        return(dict);
        }
        xmlFree(dict);
    }
    return(NULL);
}

Referenced by xmlDictCreateSub(), xmlInitParserCtxt(), and xsltNewStylesheet().

xmlDictCreateSub()

XMLPUBFUN xmlDictPtr XMLCALL xmlDictCreateSub

(

xmlDictPtr

sub

)

xmlDictCreateSub: @sub: an existing dictionary

Create a new dictionary, inheriting strings from the read-only dictionary @sub. On lookup, strings are first searched in the new dictionary, then in @sub, and if not found are created in the new dictionary.

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

Definition at line 615 of file dict.c.

                                 {
    xmlDictPtr dict = xmlDictCreate();

    if ((dict != NULL) && (sub != NULL)) {
#ifdef DICT_DEBUG_PATTERNS
        fprintf(stderr, "R");
#endif
        dict->seed = sub->seed;
        dict->subdict = sub;
    xmlDictReference(dict->subdict);
    }
    return(dict);
}

Referenced by xsltNewTransformContext().

xmlDictExists()

XMLPUBFUN const xmlChar* XMLCALL xmlDictExists	(	xmlDictPtr	dict,
		const xmlChar *	name,
		int	len
	)

Definition at line 998 of file dict.c.

                                                             {
    unsigned long key, okey, nbi = 0;
    xmlDictEntryPtr insert;
    unsigned int l;

    if ((dict == NULL) || (name == NULL))
    return(NULL);

    if (len < 0)
        l = strlen((const char *) name);
    else
        l = len;
    if (((dict->limit > 0) && (l >= dict->limit)) ||
        (l > INT_MAX / 2))
        return(NULL);

    /*
     * Check for duplicate and insertion location.
     */
    okey = xmlDictComputeKey(dict, name, l);
    key = okey % dict->size;
    if (dict->dict[key].valid == 0) {
    insert = NULL;
    } else {
    for (insert = &(dict->dict[key]); insert->next != NULL;
         insert = insert->next) {
#ifdef __GNUC__
        if ((insert->okey == okey) && (insert->len == l)) {
        if (!memcmp(insert->name, name, l))
            return(insert->name);
        }
#else
        if ((insert->okey == okey) && (insert->len == l) &&
            (!xmlStrncmp(insert->name, name, l)))
        return(insert->name);
#endif
        nbi++;
    }
#ifdef __GNUC__
    if ((insert->okey == okey) && (insert->len == l)) {
        if (!memcmp(insert->name, name, l))
        return(insert->name);
    }
#else
    if ((insert->okey == okey) && (insert->len == l) &&
        (!xmlStrncmp(insert->name, name, l)))
        return(insert->name);
#endif
    }

    if (dict->subdict) {
        unsigned long skey;

        /* we cannot always reuse the same okey for the subdict */
        if (((dict->size == MIN_DICT_SIZE) &&
         (dict->subdict->size != MIN_DICT_SIZE)) ||
            ((dict->size != MIN_DICT_SIZE) &&
         (dict->subdict->size == MIN_DICT_SIZE)))
        skey = xmlDictComputeKey(dict->subdict, name, l);
    else
        skey = okey;

    key = skey % dict->subdict->size;
    if (dict->subdict->dict[key].valid != 0) {
        xmlDictEntryPtr tmp;

        for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL;
         tmp = tmp->next) {
#ifdef __GNUC__
        if ((tmp->okey == skey) && (tmp->len == l)) {
            if (!memcmp(tmp->name, name, l))
            return(tmp->name);
        }
#else
        if ((tmp->okey == skey) && (tmp->len == l) &&
            (!xmlStrncmp(tmp->name, name, l)))
            return(tmp->name);
#endif
        nbi++;
        }
#ifdef __GNUC__
        if ((tmp->okey == skey) && (tmp->len == l)) {
        if (!memcmp(tmp->name, name, l))
            return(tmp->name);
        }
#else
        if ((tmp->okey == skey) && (tmp->len == l) &&
        (!xmlStrncmp(tmp->name, name, l)))
        return(tmp->name);
#endif
    }
    }

    /* not found */
    return(NULL);
}

xmlDictFree()

XMLPUBFUN void XMLCALL xmlDictFree

(

xmlDictPtr

dict

)

xmlDictFree: @dict: the dictionary

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

Definition at line 793 of file dict.c.

                             {
    size_t i;
    xmlDictEntryPtr iter;
    xmlDictEntryPtr next;
    int inside_dict = 0;
    xmlDictStringsPtr pool, nextp;

    if (dict == NULL)
    return;

    if (!xmlDictInitialized)
        if (!__xmlInitializeDict())
            return;

    /* decrement the counter, it may be shared by a parser and docs */
    xmlRMutexLock(xmlDictMutex);
    dict->ref_counter--;
    if (dict->ref_counter > 0) {
        xmlRMutexUnlock(xmlDictMutex);
        return;
    }

    xmlRMutexUnlock(xmlDictMutex);

    if (dict->subdict != NULL) {
        xmlDictFree(dict->subdict);
    }

    if (dict->dict) {
    for(i = 0; ((i < dict->size) && (dict->nbElems > 0)); i++) {
        iter = &(dict->dict[i]);
        if (iter->valid == 0)
        continue;
        inside_dict = 1;
        while (iter) {
        next = iter->next;
        if (!inside_dict)
            xmlFree(iter);
        dict->nbElems--;
        inside_dict = 0;
        iter = next;
        }
    }
    xmlFree(dict->dict);
    }
    pool = dict->strings;
    while (pool != NULL) {
        nextp = pool->next;
    xmlFree(pool);
    pool = nextp;
    }
    xmlFree(dict);
}

Referenced by xmlFreeParserCtxt(), xmlHashFree(), xmlParseBalancedChunkMemoryInternal(), xmlParseCtxtExternalEntity(), xmlParseInNodeContext(), xsltDocDefaultLoaderFunc(), xsltFreeStylesheet(), xsltFreeTransformContext(), and xsltParseStylesheetImportedDoc().

xmlDictGetUsage()

XMLPUBFUN size_t XMLCALL xmlDictGetUsage

(

xmlDictPtr

dict

)

xmlDictGetUsage: @dict: the dictionary

Get how much memory is used by a dictionary for strings Added in 2.9.0

Returns the amount of strings allocated

Definition at line 1276 of file dict.c.

                                 {
    xmlDictStringsPtr pool;
    size_t limit = 0;

    if (dict == NULL)
    return(0);
    pool = dict->strings;
    while (pool != NULL) {
        limit += pool->size;
    pool = pool->next;
    }
    return(limit);
}

xmlDictLookup()

XMLPUBFUN const xmlChar* XMLCALL xmlDictLookup	(	xmlDictPtr	dict,
		const xmlChar *	name,
		int	len
	)

Definition at line 858 of file dict.c.

                                                             {
    unsigned long key, okey, nbi = 0;
    xmlDictEntryPtr entry;
    xmlDictEntryPtr insert;
    const xmlChar *ret;
    unsigned int l;

    if ((dict == NULL) || (name == NULL))
    return(NULL);

    if (len < 0)
        l = strlen((const char *) name);
    else
        l = len;

    if (((dict->limit > 0) && (l >= dict->limit)) ||
        (l > INT_MAX / 2))
        return(NULL);

    /*
     * Check for duplicate and insertion location.
     */
    okey = xmlDictComputeKey(dict, name, l);
    key = okey % dict->size;
    if (dict->dict[key].valid == 0) {
    insert = NULL;
    } else {
    for (insert = &(dict->dict[key]); insert->next != NULL;
         insert = insert->next) {
#ifdef __GNUC__
        if ((insert->okey == okey) && (insert->len == l)) {
        if (!memcmp(insert->name, name, l))
            return(insert->name);
        }
#else
        if ((insert->okey == okey) && (insert->len == l) &&
            (!xmlStrncmp(insert->name, name, l)))
        return(insert->name);
#endif
        nbi++;
    }
#ifdef __GNUC__
    if ((insert->okey == okey) && (insert->len == l)) {
        if (!memcmp(insert->name, name, l))
        return(insert->name);
    }
#else
    if ((insert->okey == okey) && (insert->len == l) &&
        (!xmlStrncmp(insert->name, name, l)))
        return(insert->name);
#endif
    }

    if (dict->subdict) {
        unsigned long skey;

        /* we cannot always reuse the same okey for the subdict */
        if (((dict->size == MIN_DICT_SIZE) &&
         (dict->subdict->size != MIN_DICT_SIZE)) ||
            ((dict->size != MIN_DICT_SIZE) &&
         (dict->subdict->size == MIN_DICT_SIZE)))
        skey = xmlDictComputeKey(dict->subdict, name, l);
    else
        skey = okey;

    key = skey % dict->subdict->size;
    if (dict->subdict->dict[key].valid != 0) {
        xmlDictEntryPtr tmp;

        for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL;
         tmp = tmp->next) {
#ifdef __GNUC__
        if ((tmp->okey == skey) && (tmp->len == l)) {
            if (!memcmp(tmp->name, name, l))
            return(tmp->name);
        }
#else
        if ((tmp->okey == skey) && (tmp->len == l) &&
            (!xmlStrncmp(tmp->name, name, l)))
            return(tmp->name);
#endif
        nbi++;
        }
#ifdef __GNUC__
        if ((tmp->okey == skey) && (tmp->len == l)) {
        if (!memcmp(tmp->name, name, l))
            return(tmp->name);
        }
#else
        if ((tmp->okey == skey) && (tmp->len == l) &&
        (!xmlStrncmp(tmp->name, name, l)))
        return(tmp->name);
#endif
    }
    key = okey % dict->size;
    }

    ret = xmlDictAddString(dict, name, l);
    if (ret == NULL)
        return(NULL);
    if (insert == NULL) {
    entry = &(dict->dict[key]);
    } else {
    entry = xmlMalloc(sizeof(xmlDictEntry));
    if (entry == NULL)
         return(NULL);
    }
    entry->name = ret;
    entry->len = l;
    entry->next = NULL;
    entry->valid = 1;
    entry->okey = okey;


    if (insert != NULL)
    insert->next = entry;

    dict->nbElems++;

    if ((nbi > MAX_HASH_LEN) &&
        (dict->size <= ((MAX_DICT_HASH / 2) / MAX_HASH_LEN))) {
    if (xmlDictGrow(dict, MAX_HASH_LEN * 2 * dict->size) != 0)
        return(NULL);
    }
    /* Note that entry may have been freed at this point by xmlDictGrow */

    return(ret);
}

Referenced by xmlAddAttributeDecl(), xmlAddDefAttrs(), xmlAddID(), xmlCopyDocElementContent(), xmlDetectSAX2(), xmlDictQLookup(), xmlHashAddEntry3(), xmlHashUpdateEntry3(), xmlNewDocElementContent(), xmlParseBalancedChunkMemoryInternal(), xmlParseCtxtExternalEntity(), xmlParseInNodeContext(), xmlParseName(), xmlParseNameComplex(), xmlParseNCName(), xmlParseNCNameComplex(), xmlParseQName(), xmlParseReference(), xmlParseStartTag2(), xmlSAX2TextNode(), xsltAddTemplate(), xsltApplyAttributeSet(), xsltApplyStylesheetInternal(), xsltAttribute(), xsltAttributeComp(), xsltAttrListTemplateProcess(), xsltAttrTemplateProcess(), xsltElement(), xsltElementComp(), xsltEvalStaticAttrValueTemplate(), xsltGetCNsProp(), xsltGetQNameProperty(), xsltGetQNameURI2(), xsltNumberComp(), xsltParseStylesheetAttributeSet(), xsltParseStylesheetTemplate(), xsltParseTemplateContent(), xsltPreprocessStylesheet(), xsltProcessUserParamInternal(), xsltRegisterGlobalVariable(), xsltShallowCopyAttr(), xsltSortComp(), xsltSplitQName(), xsltStackLookup(), and xsltXPathVariableLookup().

xmlDictOwns()

XMLPUBFUN int XMLCALL xmlDictOwns	(	xmlDictPtr	dict,
		const xmlChar *	str
	)

xmlDictOwns: @dict: the dictionary @str: the string

check if a string is owned by the disctionary

Returns 1 if true, 0 if false and -1 in case of error -1 in case of error

Definition at line 1211 of file dict.c.

                                                 {
    xmlDictStringsPtr pool;

    if ((dict == NULL) || (str == NULL))
    return(-1);
    pool = dict->strings;
    while (pool != NULL) {
        if ((str >= &pool->array[0]) && (str <= pool->free))
        return(1);
    pool = pool->next;
    }
    if (dict->subdict)
        return(xmlDictOwns(dict->subdict, str));
    return(0);
}

Referenced by xmlFreeAttribute(), xmlFreeDocElementContent(), xmlHashAddEntry3(), xmlHashUpdateEntry3(), xmlParseEnumerationType(), xmlParseNotationType(), xmlSAX2Characters(), xmlSAX2ExternalSubset(), xsltAttrListTemplateProcess(), xsltAttrTemplateProcess(), xsltCopyText(), xsltParseTemplateContent(), and xsltPreprocessStylesheet().

xmlDictQLookup()

XMLPUBFUN const xmlChar* XMLCALL xmlDictQLookup	(	xmlDictPtr	dict,
		const xmlChar *	prefix,
		const xmlChar *	name
	)

Definition at line 1106 of file dict.c.

                                                                            {
    unsigned long okey, key, nbi = 0;
    xmlDictEntryPtr entry;
    xmlDictEntryPtr insert;
    const xmlChar *ret;
    unsigned int len, plen, l;

    if ((dict == NULL) || (name == NULL))
    return(NULL);
    if (prefix == NULL)
        return(xmlDictLookup(dict, name, -1));

    l = len = strlen((const char *) name);
    plen = strlen((const char *) prefix);
    len += 1 + plen;

    /*
     * Check for duplicate and insertion location.
     */
    okey = xmlDictComputeQKey(dict, prefix, plen, name, l);
    key = okey % dict->size;
    if (dict->dict[key].valid == 0) {
    insert = NULL;
    } else {
    for (insert = &(dict->dict[key]); insert->next != NULL;
         insert = insert->next) {
        if ((insert->okey == okey) && (insert->len == len) &&
            (xmlStrQEqual(prefix, name, insert->name)))
        return(insert->name);
        nbi++;
    }
    if ((insert->okey == okey) && (insert->len == len) &&
        (xmlStrQEqual(prefix, name, insert->name)))
        return(insert->name);
    }

    if (dict->subdict) {
        unsigned long skey;

        /* we cannot always reuse the same okey for the subdict */
        if (((dict->size == MIN_DICT_SIZE) &&
         (dict->subdict->size != MIN_DICT_SIZE)) ||
            ((dict->size != MIN_DICT_SIZE) &&
         (dict->subdict->size == MIN_DICT_SIZE)))
        skey = xmlDictComputeQKey(dict->subdict, prefix, plen, name, l);
    else
        skey = okey;

    key = skey % dict->subdict->size;
    if (dict->subdict->dict[key].valid != 0) {
        xmlDictEntryPtr tmp;
        for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL;
         tmp = tmp->next) {
        if ((tmp->okey == skey) && (tmp->len == len) &&
            (xmlStrQEqual(prefix, name, tmp->name)))
            return(tmp->name);
        nbi++;
        }
        if ((tmp->okey == skey) && (tmp->len == len) &&
        (xmlStrQEqual(prefix, name, tmp->name)))
        return(tmp->name);
    }
    key = okey % dict->size;
    }

    ret = xmlDictAddQString(dict, prefix, plen, name, l);
    if (ret == NULL)
        return(NULL);
    if (insert == NULL) {
    entry = &(dict->dict[key]);
    } else {
    entry = xmlMalloc(sizeof(xmlDictEntry));
    if (entry == NULL)
         return(NULL);
    }
    entry->name = ret;
    entry->len = len;
    entry->next = NULL;
    entry->valid = 1;
    entry->okey = okey;

    if (insert != NULL)
    insert->next = entry;

    dict->nbElems++;

    if ((nbi > MAX_HASH_LEN) &&
        (dict->size <= ((MAX_DICT_HASH / 2) / MAX_HASH_LEN)))
    xmlDictGrow(dict, MAX_HASH_LEN * 2 * dict->size);
    /* Note that entry may have been freed at this point by xmlDictGrow */

    return(ret);
}

Referenced by xmlSAX2StartElementNs(), xsltApplyStylesheetInternal(), and xsltDocumentElem().

xmlDictReference()

XMLPUBFUN int XMLCALL xmlDictReference

(

xmlDictPtr

dict

)

xmlDictReference: @dict: the dictionary

Increment the reference counter of a dictionary

Returns 0 in case of success and -1 in case of error

Definition at line 638 of file dict.c.

                                  {
    if (!xmlDictInitialized)
        if (!__xmlInitializeDict())
            return(-1);

    if (dict == NULL) return -1;
    xmlRMutexLock(xmlDictMutex);
    dict->ref_counter++;
    xmlRMutexUnlock(xmlDictMutex);
    return(0);
}

Referenced by xmlDictCreateSub(), xmlHashCreateDict(), xmlParseBalancedChunkMemoryInternal(), xmlParseCtxtExternalEntity(), xmlParseExternalEntityPrivate(), xmlSAX2StartDocument(), xsltApplyStylesheetInternal(), xsltCreateRVT(), xsltDocDefaultLoaderFunc(), xsltDocumentElem(), xsltLoadStylesheetPI(), and xsltParseStylesheetImportedDoc().

xmlDictSetLimit()

XMLPUBFUN size_t XMLCALL xmlDictSetLimit	(	xmlDictPtr	dict,
		size_t	limit
	)

xmlDictSetLimit: @dict: the dictionary @limit: the limit in bytes

Set a size limit for the dictionary Added in 2.9.0

Returns the previous limit of the dictionary or 0

Definition at line 1256 of file dict.c.

                                               {
    size_t ret;

    if (dict == NULL)
    return(0);
    ret = dict->limit;
    dict->limit = limit;
    return(ret);
}

Referenced by xmlCtxtUseOptionsInternal(), and xmlInitParserCtxt().

xmlDictSize()

XMLPUBFUN int XMLCALL xmlDictSize

(

xmlDictPtr

dict

)

xmlDictSize: @dict: the dictionary

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

Returns the number of elements in the dictionary or -1 in case of error

Definition at line 1237 of file dict.c.

                             {
    if (dict == NULL)
    return(-1);
    if (dict->subdict)
        return(dict->nbElems + dict->subdict->nbElems);
    return(dict->nbElems);
}

xmlInitializeDict()

XMLPUBFUN int XMLCALL xmlInitializeDict

(

void

)

xmlInitializeDict:

Do the dictionary mutex initialization. this function is deprecated

Returns 0 if initialization was already done, and 1 if that call led to the initialization

Definition at line 159 of file dict.c.

                            {
    return(0);
}

Referenced by xmlInitParser().

Variable Documentation

xmlDictPtr

__XML_EXTERNC typedef xmlDict* xmlDictPtr

Definition at line 24 of file dict.h.

Referenced by xmlAddAttributeDecl(), xmlAddElementDecl(), xmlAddNotationDecl(), xmlCopyDocElementContent(), xmlCtxtReset(), xmlDictCreate(), xmlDictCreateSub(), xmlFreeAttribute(), xmlFreeDocElementContent(), xmlFreeID(), xmlGetDtdElementDesc2(), and xmlNewDocElementContent().