Roll libxml to 8effcb578e0590cc01bbcab0f9dccefc6bdbcdbd

third_party/libxml/src/dict.c

 /*
  * dict.c: dictionary of reusable strings, just used to avoid allocation
  *         and freeing operations.
  *
  * Copyright (C) 2003-2012 Daniel Veillard.
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
@@ skipping 69 matching lines @@
        xmlDictComputeBigQKey(prefix, plen, name, len, (dict)->seed)))
 
 #else /* !WITH_BIG_KEY */
 #define xmlDictComputeKey(dict, name, len)                              \
         xmlDictComputeFastKey(name, len, (dict)->seed)
 #define xmlDictComputeQKey(dict, prefix, plen, name, len)               \
         xmlDictComputeFastQKey(prefix, plen, name, len, (dict)->seed)
 #endif /* WITH_BIG_KEY */
 
 /*
- * An entry in the dictionnary
+ * An entry in the dictionary
  */
 typedef struct _xmlDictEntry xmlDictEntry;
 typedef xmlDictEntry *xmlDictEntryPtr;
 struct _xmlDictEntry {
     struct _xmlDictEntry *next;
     const xmlChar *name;
     unsigned int len;
     int valid;
     unsigned long okey;
 };
 
 typedef struct _xmlDictStrings xmlDictStrings;
 typedef xmlDictStrings *xmlDictStringsPtr;
 struct _xmlDictStrings {
     xmlDictStringsPtr next;
     xmlChar *free;
     xmlChar *end;
     size_t size;
     size_t nbStrings;
     xmlChar array[1];
 };
 /*
- * The entire dictionnary
+ * The entire dictionary
  */
 struct _xmlDict {
     int ref_counter;
 
     struct _xmlDictEntry *dict;
     size_t size;
     unsigned int nbElems;
     xmlDictStringsPtr strings;
 
     struct _xmlDict *subdict;
@@ skipping 98 matching lines @@
     if (!xmlDictInitialized)
         return;
 
     xmlFreeRMutex(xmlDictMutex);
 
     xmlDictInitialized = 0;
 }
 
 /*
  * xmlDictAddString:
- * @dict: the dictionnary
+ * @dict: the dictionary
  * @name: the name of the userdata
  * @len: the length of the name
  *
  * Add the string to the array[s]
  *
  * Returns the pointer of the local string, or NULL in case of error.
  */
 static const xmlChar *
 xmlDictAddString(xmlDictPtr dict, const xmlChar *name, unsigned int namelen) {
     xmlDictStringsPtr pool;
@@ skipping 41 matching lines @@
     ret = pool->free;
     memcpy(pool->free, name, namelen);
     pool->free += namelen;
     *(pool->free++) = 0;
     pool->nbStrings++;
     return(ret);
 }
 
 /*
  * xmlDictAddQString:
- * @dict: the dictionnary
+ * @dict: the dictionary
  * @prefix: the prefix of the userdata
  * @plen: the prefix length
  * @name: the name of the userdata
  * @len: the length of the name
  *
  * Add the QName to the array[s]
  *
  * Returns the pointer of the local string, or NULL in case of error.
  */
 static const xmlChar *
@@ skipping 221 matching lines @@
         default: break;
     }
     return(value);
 }
 
 /**
  * xmlDictCreate:
  *
  * Create a new dictionary
  *
- * Returns the newly created dictionnary, or NULL if an error occured.
+ * Returns the newly created dictionary, or NULL if an error occured.
  */
 xmlDictPtr
 xmlDictCreate(void) {
     xmlDictPtr dict;
 
     if (!xmlDictInitialized)
         if (!__xmlInitializeDict())
             return(NULL);
 
 #ifdef DICT_DEBUG_PATTERNS
@@ skipping 19 matching lines @@
 #endif
             return(dict);
         }
         xmlFree(dict);
     }
     return(NULL);
 }
 
 /**
  * xmlDictCreateSub:
- * @sub: an existing dictionnary
+ * @sub: an existing dictionary
  *
  * Create a new dictionary, inheriting strings from the read-only
- * dictionnary @sub. On lookup, strings are first searched in the
- * new dictionnary, then in @sub, and if not found are created in the
- * new dictionnary.
+ * 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 dictionnary, or NULL if an error occured.
+ * Returns the newly created dictionary, or NULL if an error occured.
  */
 xmlDictPtr
 xmlDictCreateSub(xmlDictPtr sub) {
     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);
 }
 
 /**
  * xmlDictReference:
- * @dict: the dictionnary
+ * @dict: the dictionary
  *
  * Increment the reference counter of a dictionary
  *
  * Returns 0 in case of success and -1 in case of error
  */
 int
 xmlDictReference(xmlDictPtr dict) {
     if (!xmlDictInitialized)
         if (!__xmlInitializeDict())
             return(-1);
 
     if (dict == NULL) return -1;
     xmlRMutexLock(xmlDictMutex);
     dict->ref_counter++;
     xmlRMutexUnlock(xmlDictMutex);
     return(0);
 }
 
 /**
  * xmlDictGrow:
- * @dict: the dictionnary
- * @size: the new size of the dictionnary
+ * @dict: the dictionary
+ * @size: the new size of the dictionary
  *
- * resize the dictionnary
+ * resize the dictionary
  *
  * Returns 0 in case of success, -1 in case of failure
  */
 static int
 xmlDictGrow(xmlDictPtr dict, size_t size) {
     unsigned long key, okey;
     size_t oldsize, i;
     xmlDictEntryPtr iter, next;
     struct _xmlDictEntry *olddict;
 #ifdef DEBUG_GROW
@@ skipping 111 matching lines @@
 #ifdef DEBUG_GROW
     xmlGenericError(xmlGenericErrorContext,
             "xmlDictGrow : from %lu to %lu, %u elems\n", oldsize, size, nbElem);
 #endif
 
     return(ret);
 }
 
 /**
  * xmlDictFree:
- * @dict: the dictionnary
+ * @dict: the dictionary
  *
  * Free the hash @dict and its contents. The userdata is
  * deallocated with @f if provided.
  */
 void
 xmlDictFree(xmlDictPtr dict) {
     size_t i;
     xmlDictEntryPtr iter;
     xmlDictEntryPtr next;
     int inside_dict = 0;
@@ skipping 41 matching lines @@
     while (pool != NULL) {
         nextp = pool->next;
         xmlFree(pool);
         pool = nextp;
     }
     xmlFree(dict);
 }
 
 /**
  * xmlDictLookup:
- * @dict: the dictionnary
+ * @dict: the dictionary
  * @name: the name of the userdata
  * @len: the length of the name, if -1 it is recomputed
  *
- * Add the @name to the dictionnary @dict if not present.
+ * Add the @name to the dictionary @dict if not present.
  *
  * Returns the internal copy of the name or NULL in case of internal error
  */
 const xmlChar *
 xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {
     unsigned long key, okey, nbi = 0;
     xmlDictEntryPtr entry;
     xmlDictEntryPtr insert;
     const xmlChar *ret;
     unsigned int l;
@@ skipping 115 matching lines @@
         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);
 }
 
 /**
  * xmlDictExists:
- * @dict: the dictionnary
+ * @dict: the dictionary
  * @name: the name of the userdata
  * @len: the length of the name, if -1 it is recomputed
  *
- * Check if the @name exists in the dictionnary @dict.
+ * Check if the @name exists in the dictionary @dict.
  *
  * Returns the internal copy of the name or NULL if not found.
  */
 const xmlChar *
 xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) {
     unsigned long key, okey, nbi = 0;
     xmlDictEntryPtr insert;
     unsigned int l;
 
     if ((dict == NULL) || (name == NULL))
@@ skipping 83 matching lines @@
 #endif
         }
     }
 
     /* not found */
     return(NULL);
 }
 
 /**
  * xmlDictQLookup:
- * @dict: the dictionnary
+ * @dict: the dictionary
  * @prefix: the prefix
  * @name: the name
  *
  * Add the QName @prefix:@name to the hash @dict if not present.
  *
  * Returns the internal copy of the QName or NULL in case of internal error
  */
 const xmlChar *
 xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name) {
     unsigned long okey, key, nbi = 0;
@@ skipping 84 matching lines @@
     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);
 }
 
 /**
  * xmlDictOwns:
- * @dict: the dictionnary
+ * @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
  */
 int
 xmlDictOwns(xmlDictPtr dict, const xmlChar *str) {
     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);
 }
 
 /**
  * xmlDictSize:
- * @dict: the dictionnary
+ * @dict: the dictionary
  *
  * Query the number of elements installed in the hash @dict.
  *
- * Returns the number of elements in the dictionnary or
+ * Returns the number of elements in the dictionary or
  * -1 in case of error
  */
 int
 xmlDictSize(xmlDictPtr dict) {
     if (dict == NULL)
         return(-1);
     if (dict->subdict)
         return(dict->nbElems + dict->subdict->nbElems);
     return(dict->nbElems);
 }
 
 /**
  * xmlDictSetLimit:
- * @dict: the dictionnary
+ * @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
  */
 size_t
 xmlDictSetLimit(xmlDictPtr dict, size_t limit) {
     size_t ret;
 
     if (dict == NULL)
         return(0);
     ret = dict->limit;
     dict->limit = limit;
     return(ret);
 }
 
 /**
  * xmlDictGetUsage:
- * @dict: the dictionnary
+ * @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
  */
 size_t
 xmlDictGetUsage(xmlDictPtr dict) {
     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);
 }
 
 #define bottom_dict
 #include "elfgcchack.h"