/* * xmlDictComputeQKey: * Calculate the hash key */ static unsigned long xmlDictComputeQKey(const xmlChar *prefix, const xmlChar *name, intptr_t len) { unsigned long value = 0L; size_t plen; if (prefix == NULL) return(xmlDictComputeKey(name, len)); plen = xmlStrlen(prefix); if (plen == 0) value += 30 * (unsigned long) ':'; else value += 30 * (*prefix); if (len > 10) { value += name[len - (plen + 1 + 1)]; len = 10; if (plen > 10) plen = 10; } switch (plen) { case 10: value += prefix[9]; case 9: value += prefix[8]; case 8: value += prefix[7]; case 7: value += prefix[6]; case 6: value += prefix[5]; case 5: value += prefix[4]; case 4: value += prefix[3]; case 3: value += prefix[2]; case 2: value += prefix[1]; case 1: value += prefix[0]; default: break; } len -= plen; if (len > 0) { value += (unsigned long) ':'; len--; } switch (len) { case 10: value += name[9]; case 9: value += name[8]; case 8: value += name[7]; case 7: value += name[6]; case 6: value += name[5]; case 5: value += name[4]; case 4: value += name[3]; case 3: value += name[2]; case 2: value += name[1]; case 1: value += name[0]; default: break; } return(value); }
/** * xmlDictLookup: * @param dict the dictionnary * @param name the name of the userdata * @param len the length of the name, if -1 it is recomputed * * Add the name to the hash dict if not present. * * Returns the internal copy of the name or NULL in case of internal error * * OOM: possible --> returns NULL and OOM flag is set */ XMLPUBFUNEXPORT const xmlChar* xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) { unsigned long key, okey, nbi = 0; xmlDictEntryPtr entry; xmlDictEntryPtr insert; const xmlChar *ret; if (!dict || !name) return(NULL); if (len < 0) len = xmlStrlen(name); /* * Check for duplicate and insertion location. */ okey = xmlDictComputeKey(name, len); key = okey % dict->size; if (dict->dict[key].valid == 0) { insert = NULL; } else { for (insert = &(dict->dict[key]); insert->next; insert = insert->next) { #ifdef __GNUC__ if (insert->len == len) { if (!memcmp(insert->name, name, len)) return(insert->name); } #else if ((insert->len == len) && (!xmlStrncmp(insert->name, name, len))) return(insert->name); #endif nbi++; } #ifdef __GNUC__ if (insert->len == len) { if (!memcmp(insert->name, name, len)) return(insert->name); } #else if ((insert->len == len) && (!xmlStrncmp(insert->name, name, len))) return(insert->name); #endif } if (dict->subdict) { key = okey % 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->len == len) { if (!memcmp(tmp->name, name, len)) return(tmp->name); } #else if ((tmp->len == len) && (!xmlStrncmp(tmp->name, name, len))) return(tmp->name); #endif nbi++; } #ifdef __GNUC__ if (tmp->len == len) { if (!memcmp(tmp->name, name, len)) return(tmp->name); } #else if ((tmp->len == len) && (!xmlStrncmp(tmp->name, name, len))) return(tmp->name); #endif } // if (dict->subdict->dict[key].valid != 0) key = okey % dict->size; } // if (dict->subdict) ret = xmlDictAddString(dict, name, len); // may set OOM flag if (!ret) return(NULL); if (!insert) { entry = &(dict->dict[key]); } else { entry = (xmlDictEntryPtr)xmlMalloc(sizeof(xmlDictEntry)); if (!entry) return(NULL); //OOM } entry->name = ret; entry->len = len; entry->next = NULL; entry->valid = 1; if (insert) 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); if(OOM_FLAG) return NULL; } /* Note that entry may have been freed at this point by xmlDictGrow */ return(ret); }
/** * xmlDictGrow: * @param dict the dictionnary * @param size the new size of the dictionnary * * resize the dictionnary * * Returns 0 in case of success, -1 in case of failure * * OOM: possible --> returns -1, OOM is set */ static int xmlDictGrow(xmlDictPtr dict, int size) { unsigned long key; int oldsize, i; xmlDictEntryPtr iter, next; struct _xmlDictEntry *olddict; #ifdef DEBUG_GROW unsigned long nbElem = 0; #endif if (!dict || size < 8 || size > 8 * 2048) return(-1); oldsize = dict->size; olddict = dict->dict; if (!olddict) return(-1); dict->dict = (xmlDictEntryPtr)xmlMalloc(size * sizeof(xmlDictEntry)); if (!dict->dict) { dict->dict = olddict; return(-1); } memset(dict->dict, 0, size * sizeof(xmlDictEntry)); dict->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 dict. 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 (olddict[i].valid == 0) continue; key = xmlDictComputeKey(olddict[i].name, olddict[i].len) % dict->size; memcpy(&(dict->dict[key]), &(olddict[i]), sizeof(xmlDictEntry)); dict->dict[key].next = NULL; #ifdef DEBUG_GROW nbElem++; #endif } for (i = 0; i < oldsize; i++) { iter = olddict[i].next; while (iter) { next = iter->next; /* * put back the entry in the new dict */ key = xmlDictComputeKey(iter->name, iter->len) % dict->size; if (dict->dict[key].valid == 0) { memcpy(&(dict->dict[key]), iter, sizeof(xmlDictEntry)); dict->dict[key].next = NULL; dict->dict[key].valid = 1; xmlFree(iter); } else { iter->next = dict->dict[key].next; dict->dict[key].next = iter; } #ifdef DEBUG_GROW nbElem++; #endif iter = next; } // while (iter) } // for (i = 0; i < oldsize; i++) xmlFree(olddict); #ifdef DEBUG_GROW xmlGenericError(xmlGenericErrorContext, "xmlDictGrow : from %d to %d, %d elems\n", oldsize, size, nbElem); #endif return(0); }
/* * xmlDictComputeQKey: * Calculate the hash key */ static unsigned long xmlDictComputeQKey(const xmlChar *prefix, const xmlChar *name, int len) { unsigned long value; // = 0L; //avoided initialization int plen; if (!prefix) return(xmlDictComputeKey(name, len)); plen = xmlStrlen(prefix); value = 30 * (plen ? *prefix : (unsigned long) ':'); if (len > 10) { value += name[len - (plen + 1 + 1)]; len = 10; if (plen > 10) plen = 10; } // DONE: OPTIMIZE: see "Optimize-It" note in xmlDictComputeKey /* switch (plen) { case 10: value += prefix[9]; case 9: value += prefix[8]; case 8: value += prefix[7]; case 7: value += prefix[6]; case 6: value += prefix[5]; case 5: value += prefix[4]; case 4: value += prefix[3]; case 3: value += prefix[2]; case 2: value += prefix[1]; case 1: value += prefix[0]; default: break; } */ // REPLACED WITH if (plen < 11 && plen >0) value += prefix[plen-1]; //------------------------------------- len -= plen; if (len > 0) { value += (unsigned long) ':'; len--; } /* --- REPLACED switch (len) { case 10: value += name[9]; case 9: value += name[8]; case 8: value += name[7]; case 7: value += name[6]; case 6: value += name[5]; case 5: value += name[4]; case 4: value += name[3]; case 3: value += name[2]; case 2: value += name[1]; case 1: value += name[0]; default: break; } */ //-- REPLACED WITH if(len > 0 && len < 11) value += name[len-1]; //-------------------- return(value); }
/** * xmlDictExists: * @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 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)) 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); }
/** * xmlDictLookup: * @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 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; 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); }
/** * xmlDictGrow: * @dict: the dictionary * @size: the new size of the dictionary * * 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 unsigned long nbElem = 0; #endif int ret = 0; int keep_keys = 1; if (dict == NULL) return(-1); if (size < 8) return(-1); if (size > 8 * 2048) return(-1); #ifdef DICT_DEBUG_PATTERNS fprintf(stderr, "*"); #endif oldsize = dict->size; olddict = dict->dict; if (olddict == NULL) return(-1); if (oldsize == MIN_DICT_SIZE) keep_keys = 0; dict->dict = xmlMalloc(size * sizeof(xmlDictEntry)); if (dict->dict == NULL) { dict->dict = olddict; return(-1); } memset(dict->dict, 0, size * sizeof(xmlDictEntry)); dict->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 dict. It is nicer to run through the array twice, first copying all the elements in the main array (less probability of allocate) and then the rest, so we only free in the second loop. */ for (i = 0; i < oldsize; i++) { if (olddict[i].valid == 0) continue; if (keep_keys) okey = olddict[i].okey; else okey = xmlDictComputeKey(dict, olddict[i].name, olddict[i].len); key = okey % dict->size; if (dict->dict[key].valid == 0) { memcpy(&(dict->dict[key]), &(olddict[i]), sizeof(xmlDictEntry)); dict->dict[key].next = NULL; dict->dict[key].okey = okey; } else { xmlDictEntryPtr entry; entry = xmlMalloc(sizeof(xmlDictEntry)); if (entry != NULL) { entry->name = olddict[i].name; entry->len = olddict[i].len; entry->okey = okey; entry->next = dict->dict[key].next; entry->valid = 1; dict->dict[key].next = entry; } else { /* * we don't have much ways to alert from herei * result is loosing an entry and unicity garantee */ ret = -1; } } #ifdef DEBUG_GROW nbElem++; #endif } for (i = 0; i < oldsize; i++) { iter = olddict[i].next; while (iter) { next = iter->next; /* * put back the entry in the new dict */ if (keep_keys) okey = iter->okey; else okey = xmlDictComputeKey(dict, iter->name, iter->len); key = okey % dict->size; if (dict->dict[key].valid == 0) { memcpy(&(dict->dict[key]), iter, sizeof(xmlDictEntry)); dict->dict[key].next = NULL; dict->dict[key].valid = 1; dict->dict[key].okey = okey; xmlFree(iter); } else { iter->next = dict->dict[key].next; iter->okey = okey; dict->dict[key].next = iter; } #ifdef DEBUG_GROW nbElem++; #endif iter = next; } } xmlFree(olddict); #ifdef DEBUG_GROW xmlGenericError(xmlGenericErrorContext, "xmlDictGrow : from %lu to %lu, %u elems\n", oldsize, size, nbElem); #endif return(ret); }
const xmlChar * xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) { unsigned long key, okey, nbi = 0; xmlDictEntryPtr insert; if ((dict == NULL) || (name == NULL)) return(NULL); if (len < 0) len = strlen((const char *) name); okey = xmlDictComputeKey(dict, name, len); 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 == len)) { if (!memcmp(insert->name, name, len)) return(insert->name); } #else if ((insert->okey == okey) && (insert->len == len) && (!xmlStrncmp(insert->name, name, len))) return(insert->name); #endif nbi++; } #ifdef __GNUC__ if ((insert->okey == okey) && (insert->len == len)) { if (!memcmp(insert->name, name, len)) return(insert->name); } #else if ((insert->okey == okey) && (insert->len == len) && (!xmlStrncmp(insert->name, name, len))) return(insert->name); #endif } if (dict->subdict) { unsigned long skey; 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, len); 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 == len)) { if (!memcmp(tmp->name, name, len)) return(tmp->name); } #else if ((tmp->okey == skey) && (tmp->len == len) && (!xmlStrncmp(tmp->name, name, len))) return(tmp->name); #endif nbi++; } #ifdef __GNUC__ if ((tmp->okey == skey) && (tmp->len == len)) { if (!memcmp(tmp->name, name, len)) return(tmp->name); } #else if ((tmp->okey == skey) && (tmp->len == len) && (!xmlStrncmp(tmp->name, name, len))) return(tmp->name); #endif } } return(NULL); }
const xmlChar * xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) { unsigned long key, okey, nbi = 0; xmlDictEntryPtr entry; xmlDictEntryPtr insert; const xmlChar *ret; if ((dict == NULL) || (name == NULL)) return(NULL); if (len < 0) len = strlen((const char *) name); okey = xmlDictComputeKey(dict, name, len); 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 == len)) { if (!memcmp(insert->name, name, len)) return(insert->name); } #else if ((insert->okey == okey) && (insert->len == len) && (!xmlStrncmp(insert->name, name, len))) return(insert->name); #endif nbi++; } #ifdef __GNUC__ if ((insert->okey == okey) && (insert->len == len)) { if (!memcmp(insert->name, name, len)) return(insert->name); } #else if ((insert->okey == okey) && (insert->len == len) && (!xmlStrncmp(insert->name, name, len))) return(insert->name); #endif } if (dict->subdict) { unsigned long skey; 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, len); 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 == len)) { if (!memcmp(tmp->name, name, len)) return(tmp->name); } #else if ((tmp->okey == skey) && (tmp->len == len) && (!xmlStrncmp(tmp->name, name, len))) return(tmp->name); #endif nbi++; } #ifdef __GNUC__ if ((tmp->okey == skey) && (tmp->len == len)) { if (!memcmp(tmp->name, name, len)) return(tmp->name); } #else if ((tmp->okey == skey) && (tmp->len == len) && (!xmlStrncmp(tmp->name, name, len))) return(tmp->name); #endif } key = okey % dict->size; } ret = xmlDictAddString(dict, name, len); 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))) { if (xmlDictGrow(dict, MAX_HASH_LEN * 2 * dict->size) != 0) return(NULL); } return(ret); }
static int xmlDictGrow(xmlDictPtr dict, int size) { unsigned long key, okey; int oldsize, i; xmlDictEntryPtr iter, next; struct _xmlDictEntry *olddict; #ifdef DEBUG_GROW unsigned long nbElem = 0; #endif int ret = 0; int keep_keys = 1; if (dict == NULL) return(-1); if (size < 8) return(-1); if (size > 8 * 2048) return(-1); #ifdef DICT_DEBUG_PATTERNS fprintf(stderr, "*"); #endif oldsize = dict->size; olddict = dict->dict; if (olddict == NULL) return(-1); if (oldsize == MIN_DICT_SIZE) keep_keys = 0; dict->dict = xmlMalloc(size * sizeof(xmlDictEntry)); if (dict->dict == NULL) { dict->dict = olddict; return(-1); } memset(dict->dict, 0, size * sizeof(xmlDictEntry)); dict->size = size; for (i = 0; i < oldsize; i++) { if (olddict[i].valid == 0) continue; if (keep_keys) okey = olddict[i].okey; else okey = xmlDictComputeKey(dict, olddict[i].name, olddict[i].len); key = okey % dict->size; if (dict->dict[key].valid == 0) { memcpy(&(dict->dict[key]), &(olddict[i]), sizeof(xmlDictEntry)); dict->dict[key].next = NULL; dict->dict[key].okey = okey; } else { xmlDictEntryPtr entry; entry = xmlMalloc(sizeof(xmlDictEntry)); if (entry != NULL) { entry->name = olddict[i].name; entry->len = olddict[i].len; entry->okey = okey; entry->next = dict->dict[key].next; entry->valid = 1; dict->dict[key].next = entry; } else { ret = -1; } } #ifdef DEBUG_GROW nbElem++; #endif } for (i = 0; i < oldsize; i++) { iter = olddict[i].next; while (iter) { next = iter->next; if (keep_keys) okey = iter->okey; else okey = xmlDictComputeKey(dict, iter->name, iter->len); key = okey % dict->size; if (dict->dict[key].valid == 0) { memcpy(&(dict->dict[key]), iter, sizeof(xmlDictEntry)); dict->dict[key].next = NULL; dict->dict[key].valid = 1; dict->dict[key].okey = okey; xmlFree(iter); } else { iter->next = dict->dict[key].next; iter->okey = okey; dict->dict[key].next = iter; } #ifdef DEBUG_GROW nbElem++; #endif iter = next; } } xmlFree(olddict); #ifdef DEBUG_GROW xmlGenericError(xmlGenericErrorContext, "xmlDictGrow : from %d to %d, %d elems\n", oldsize, size, nbElem); #endif return(ret); }
/** * xmlDictExists: * @dict: the dictionnary * @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. * * Returns the internal copy of the name or NULL if not found. */ const xmlChar * xmlDictExists(xmlDictPtr dict, const xmlChar *name, intptr_t len) { unsigned long key, okey, nbi = 0; xmlDictEntryPtr insert; if ((dict == NULL) || (name == NULL)) return(NULL); if (len < 0) len = xmlStrlen(name); /* * Check for duplicate and insertion location. */ okey = xmlDictComputeKey(name, len); 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->len == len) { if (!memcmp(insert->name, name, len)) return(insert->name); } #else if ((insert->len == len) && (!xmlStrncmp(insert->name, name, len))) return(insert->name); #endif nbi++; } #ifdef __GNUC__ if (insert->len == len) { if (!memcmp(insert->name, name, len)) return(insert->name); } #else if ((insert->len == len) && (!xmlStrncmp(insert->name, name, len))) return(insert->name); #endif } if (dict->subdict) { key = okey % 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->len == len) { if (!memcmp(tmp->name, name, len)) return(tmp->name); } #else if ((tmp->len == len) && (!xmlStrncmp(tmp->name, name, len))) return(tmp->name); #endif nbi++; } #ifdef __GNUC__ if (tmp->len == len) { if (!memcmp(tmp->name, name, len)) return(tmp->name); } #else if ((tmp->len == len) && (!xmlStrncmp(tmp->name, name, len))) return(tmp->name); #endif } key = okey % dict->size; } /* not found */ return(NULL); }