dict.h File Reference

#include <stddef.h>
#include <libxml/xmlversion.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.

Typedefs
typedef struct _xmlDict	xmlDict
typedef xmlDict *	xmlDictPtr

Functions
XML_DEPRECATED 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)
XML_DEPRECATED XMLPUBFUN void XMLCALL	xmlDictCleanup (void)

Typedef Documentation

xmlDict

typedef struct _xmlDict xmlDict

Definition at line 24 of file dict.h.

xmlDictPtr

typedef xmlDict* xmlDictPtr

Definition at line 25 of file dict.h.

Function Documentation

xmlDictCleanup()

XML_DEPRECATED XMLPUBFUN void XMLCALL xmlDictCleanup

(

void

)

xmlDictCleanup:

DEPRECATED: This function will be made private. Call xmlCleanupParser to free global state but see the warnings there. xmlCleanupParser should be only called once at program exit. In most cases, you don't have call cleanup functions at all.

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

Definition at line 224 of file dict.c.

                     {
    if (!xmlDictInitialized)
        return;

    xmlFreeMutex(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 577 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 xsltNewStylesheetInternal().

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 624 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 1007 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 802 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 */
    xmlMutexLock(xmlDictMutex);
    dict->ref_counter--;
    if (dict->ref_counter > 0) {
        xmlMutexUnlock(xmlDictMutex);
        return;
    }

    xmlMutexUnlock(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(), xmlParseExternalEntityPrivate(), xmlParseInNodeContext(), xsltDocDefaultLoaderFunc(), xsltFreeStylesheet(), xsltFreeTransformContext(), and xsltParseStylesheetUser().

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 1285 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 867 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(), xmlParseExternalEntityPrivate(), 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 dictionary

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

Definition at line 1220 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(), xmlSAX2ExternalSubset(), xmlSAX2Text(), xsltAttrListTemplateProcess(), xsltAttrTemplateProcess(), xsltCopyText(), xsltParseTemplateContent(), and xsltPreprocessStylesheet().

xmlDictQLookup()

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

Definition at line 1115 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 647 of file dict.c.

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

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

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

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 1265 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 1246 of file dict.c.

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

xmlInitializeDict()

XML_DEPRECATED XMLPUBFUN int XMLCALL xmlInitializeDict

(

void

)

xmlInitializeDict:

DEPRECATED: This function will be made private. Call xmlInitParser to initialize the library.

Do the dictionary mutex initialization.

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

Definition at line 157 of file dict.c.

                            {
    return(0);
}

Referenced by xmlInitParser().