Change the NSS and NSPR source tree to the new directory structure to be

mozilla/nsprpub/lib/ds/plhash.c

Index: mozilla/nsprpub/lib/ds/plhash.c
===================================================================
--- mozilla/nsprpub/lib/ds/plhash.c	(revision 191424)
+++ mozilla/nsprpub/lib/ds/plhash.c	(working copy)
@@ -1,483 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/*
- * PL hash table package.
- */
-#include "plhash.h"
-#include "prbit.h"
-#include "prlog.h"
-#include "prmem.h"
-#include "prtypes.h"
-#include <stdlib.h>
-#include <string.h>
-
-/* Compute the number of buckets in ht */
-#define NBUCKETS(ht)    (1 << (PL_HASH_BITS - (ht)->shift))
-
-/* The smallest table has 16 buckets */
-#define MINBUCKETSLOG2  4
-#define MINBUCKETS      (1 << MINBUCKETSLOG2)
-
-/* Compute the maximum entries given n buckets that we will tolerate, ~90% */
-#define OVERLOADED(n)   ((n) - ((n) >> 3))
-
-/* Compute the number of entries below which we shrink the table by half */
-#define UNDERLOADED(n)  (((n) > MINBUCKETS) ? ((n) >> 2) : 0)
-
-/*
-** Stubs for default hash allocator ops.
-*/
-static void * PR_CALLBACK
-DefaultAllocTable(void *pool, PRSize size)
-{
-    return PR_MALLOC(size);
-}
-
-static void PR_CALLBACK
-DefaultFreeTable(void *pool, void *item)
-{
-    PR_Free(item);
-}
-
-static PLHashEntry * PR_CALLBACK
-DefaultAllocEntry(void *pool, const void *key)
-{
-    return PR_NEW(PLHashEntry);
-}
-
-static void PR_CALLBACK
-DefaultFreeEntry(void *pool, PLHashEntry *he, PRUintn flag)
-{
-    if (flag == HT_FREE_ENTRY)
-        PR_Free(he);
-}
-
-static PLHashAllocOps defaultHashAllocOps = {
-    DefaultAllocTable, DefaultFreeTable,
-    DefaultAllocEntry, DefaultFreeEntry
-};
-
-PR_IMPLEMENT(PLHashTable *)
-PL_NewHashTable(PRUint32 n, PLHashFunction keyHash,
-                PLHashComparator keyCompare, PLHashComparator valueCompare,
-                const PLHashAllocOps *allocOps, void *allocPriv)
-{
-    PLHashTable *ht;
-    PRSize nb;
-
-    if (n <= MINBUCKETS) {
-        n = MINBUCKETSLOG2;
-    } else {
-        n = PR_CeilingLog2(n);
-        if ((PRInt32)n < 0)
-            return 0;
-    }
-
-    if (!allocOps) allocOps = &defaultHashAllocOps;
-
-    ht = (PLHashTable*)((*allocOps->allocTable)(allocPriv, sizeof *ht));
-    if (!ht)
-	return 0;
-    memset(ht, 0, sizeof *ht);
-    ht->shift = PL_HASH_BITS - n;
-    n = 1 << n;
-    nb = n * sizeof(PLHashEntry *);
-    ht->buckets = (PLHashEntry**)((*allocOps->allocTable)(allocPriv, nb));
-    if (!ht->buckets) {
-        (*allocOps->freeTable)(allocPriv, ht);
-        return 0;
-    }
-    memset(ht->buckets, 0, nb);
-
-    ht->keyHash = keyHash;
-    ht->keyCompare = keyCompare;
-    ht->valueCompare = valueCompare;
-    ht->allocOps = allocOps;
-    ht->allocPriv = allocPriv;
-    return ht;
-}
-
-PR_IMPLEMENT(void)
-PL_HashTableDestroy(PLHashTable *ht)
-{
-    PRUint32 i, n;
-    PLHashEntry *he, *next;
-    const PLHashAllocOps *allocOps = ht->allocOps;
-    void *allocPriv = ht->allocPriv;
-
-    n = NBUCKETS(ht);
-    for (i = 0; i < n; i++) {
-        for (he = ht->buckets[i]; he; he = next) {
-            next = he->next;
-            (*allocOps->freeEntry)(allocPriv, he, HT_FREE_ENTRY);
-        }
-    }
-#ifdef DEBUG
-    memset(ht->buckets, 0xDB, n * sizeof ht->buckets[0]);
-#endif
-    (*allocOps->freeTable)(allocPriv, ht->buckets);
-#ifdef DEBUG
-    memset(ht, 0xDB, sizeof *ht);
-#endif
-    (*allocOps->freeTable)(allocPriv, ht);
-}
-
-/*
-** Multiplicative hash, from Knuth 6.4.
-*/
-#define GOLDEN_RATIO    0x9E3779B9U  /* 2/(1+sqrt(5))*(2^32) */
-
-PR_IMPLEMENT(PLHashEntry **)
-PL_HashTableRawLookup(PLHashTable *ht, PLHashNumber keyHash, const void *key)
-{
-    PLHashEntry *he, **hep, **hep0;
-    PLHashNumber h;
-
-#ifdef HASHMETER
-    ht->nlookups++;
-#endif
-    h = keyHash * GOLDEN_RATIO;
-    h >>= ht->shift;
-    hep = hep0 = &ht->buckets[h];
-    while ((he = *hep) != 0) {
-        if (he->keyHash == keyHash && (*ht->keyCompare)(key, he->key)) {
-            /* Move to front of chain if not already there */
-            if (hep != hep0) {
-                *hep = he->next;
-                he->next = *hep0;
-                *hep0 = he;
-            }
-            return hep0;
-        }
-        hep = &he->next;
-#ifdef HASHMETER
-        ht->nsteps++;
-#endif
-    }
-    return hep;
-}
-
-/*
-** Same as PL_HashTableRawLookup but doesn't reorder the hash entries.
-*/
-PR_IMPLEMENT(PLHashEntry **)
-PL_HashTableRawLookupConst(PLHashTable *ht, PLHashNumber keyHash,
-                           const void *key)
-{
-    PLHashEntry *he, **hep;
-    PLHashNumber h;
-
-#ifdef HASHMETER
-    ht->nlookups++;
-#endif
-    h = keyHash * GOLDEN_RATIO;
-    h >>= ht->shift;
-    hep = &ht->buckets[h];
-    while ((he = *hep) != 0) {
-        if (he->keyHash == keyHash && (*ht->keyCompare)(key, he->key)) {
-            break;
-        }
-        hep = &he->next;
-#ifdef HASHMETER
-        ht->nsteps++;
-#endif
-    }
-    return hep;
-}
-
-PR_IMPLEMENT(PLHashEntry *)
-PL_HashTableRawAdd(PLHashTable *ht, PLHashEntry **hep,
-                   PLHashNumber keyHash, const void *key, void *value)
-{
-    PRUint32 i, n;
-    PLHashEntry *he, *next, **oldbuckets;
-    PRSize nb;
-
-    /* Grow the table if it is overloaded */
-    n = NBUCKETS(ht);
-    if (ht->nentries >= OVERLOADED(n)) {
-        oldbuckets = ht->buckets;
-        nb = 2 * n * sizeof(PLHashEntry *);
-        ht->buckets = (PLHashEntry**)
-            ((*ht->allocOps->allocTable)(ht->allocPriv, nb));
-        if (!ht->buckets) {
-            ht->buckets = oldbuckets;
-            return 0;
-        }
-        memset(ht->buckets, 0, nb);
-#ifdef HASHMETER
-        ht->ngrows++;
-#endif
-        ht->shift--;
-
-        for (i = 0; i < n; i++) {
-            for (he = oldbuckets[i]; he; he = next) {
-                next = he->next;
-                hep = PL_HashTableRawLookup(ht, he->keyHash, he->key);
-                PR_ASSERT(*hep == 0);
-                he->next = 0;
-                *hep = he;
-            }
-        }
-#ifdef DEBUG
-        memset(oldbuckets, 0xDB, n * sizeof oldbuckets[0]);
-#endif
-        (*ht->allocOps->freeTable)(ht->allocPriv, oldbuckets);
-        hep = PL_HashTableRawLookup(ht, keyHash, key);
-    }
-
-    /* Make a new key value entry */
-    he = (*ht->allocOps->allocEntry)(ht->allocPriv, key);
-    if (!he)
-	return 0;
-    he->keyHash = keyHash;
-    he->key = key;
-    he->value = value;
-    he->next = *hep;
-    *hep = he;
-    ht->nentries++;
-    return he;
-}
-
-PR_IMPLEMENT(PLHashEntry *)
-PL_HashTableAdd(PLHashTable *ht, const void *key, void *value)
-{
-    PLHashNumber keyHash;
-    PLHashEntry *he, **hep;
-
-    keyHash = (*ht->keyHash)(key);
-    hep = PL_HashTableRawLookup(ht, keyHash, key);
-    if ((he = *hep) != 0) {
-        /* Hit; see if values match */
-        if ((*ht->valueCompare)(he->value, value)) {
-            /* key,value pair is already present in table */
-            return he;
-        }
-        if (he->value)
-            (*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_VALUE);
-        he->value = value;
-        return he;
-    }
-    return PL_HashTableRawAdd(ht, hep, keyHash, key, value);
-}
-
-PR_IMPLEMENT(void)
-PL_HashTableRawRemove(PLHashTable *ht, PLHashEntry **hep, PLHashEntry *he)
-{
-    PRUint32 i, n;
-    PLHashEntry *next, **oldbuckets;
-    PRSize nb;
-
-    *hep = he->next;
-    (*ht->allocOps->freeEntry)(ht->allocPriv, he, HT_FREE_ENTRY);
-
-    /* Shrink table if it's underloaded */
-    n = NBUCKETS(ht);
-    if (--ht->nentries < UNDERLOADED(n)) {
-        oldbuckets = ht->buckets;
-        nb = n * sizeof(PLHashEntry*) / 2;
-        ht->buckets = (PLHashEntry**)(
-            (*ht->allocOps->allocTable)(ht->allocPriv, nb));
-        if (!ht->buckets) {
-            ht->buckets = oldbuckets;
-            return;
-        }
-        memset(ht->buckets, 0, nb);
-#ifdef HASHMETER
-        ht->nshrinks++;
-#endif
-        ht->shift++;
-
-        for (i = 0; i < n; i++) {
-            for (he = oldbuckets[i]; he; he = next) {
-                next = he->next;
-                hep = PL_HashTableRawLookup(ht, he->keyHash, he->key);
-                PR_ASSERT(*hep == 0);
-                he->next = 0;
-                *hep = he;
-            }
-        }
-#ifdef DEBUG
-        memset(oldbuckets, 0xDB, n * sizeof oldbuckets[0]);
-#endif
-        (*ht->allocOps->freeTable)(ht->allocPriv, oldbuckets);
-    }
-}
-
-PR_IMPLEMENT(PRBool)
-PL_HashTableRemove(PLHashTable *ht, const void *key)
-{
-    PLHashNumber keyHash;
-    PLHashEntry *he, **hep;
-
-    keyHash = (*ht->keyHash)(key);
-    hep = PL_HashTableRawLookup(ht, keyHash, key);
-    if ((he = *hep) == 0)
-        return PR_FALSE;
-
-    /* Hit; remove element */
-    PL_HashTableRawRemove(ht, hep, he);
-    return PR_TRUE;
-}
-
-PR_IMPLEMENT(void *)
-PL_HashTableLookup(PLHashTable *ht, const void *key)
-{
-    PLHashNumber keyHash;
-    PLHashEntry *he, **hep;
-
-    keyHash = (*ht->keyHash)(key);
-    hep = PL_HashTableRawLookup(ht, keyHash, key);
-    if ((he = *hep) != 0) {
-        return he->value;
-    }
-    return 0;
-}
-
-/*
-** Same as PL_HashTableLookup but doesn't reorder the hash entries.
-*/
-PR_IMPLEMENT(void *)
-PL_HashTableLookupConst(PLHashTable *ht, const void *key)
-{
-    PLHashNumber keyHash;
-    PLHashEntry *he, **hep;
-
-    keyHash = (*ht->keyHash)(key);
-    hep = PL_HashTableRawLookupConst(ht, keyHash, key);
-    if ((he = *hep) != 0) {
-        return he->value;
-    }
-    return 0;
-}
-
-/*
-** Iterate over the entries in the hash table calling func for each
-** entry found. Stop if "f" says to (return value & PR_ENUMERATE_STOP).
-** Return a count of the number of elements scanned.
-*/
-PR_IMPLEMENT(int)
-PL_HashTableEnumerateEntries(PLHashTable *ht, PLHashEnumerator f, void *arg)
-{
-    PLHashEntry *he, **hep;
-    PRUint32 i, nbuckets;
-    int rv, n = 0;
-    PLHashEntry *todo = 0;
-
-    nbuckets = NBUCKETS(ht);
-    for (i = 0; i < nbuckets; i++) {
-        hep = &ht->buckets[i];
-        while ((he = *hep) != 0) {
-            rv = (*f)(he, n, arg);
-            n++;
-            if (rv & (HT_ENUMERATE_REMOVE | HT_ENUMERATE_UNHASH)) {
-                *hep = he->next;
-                if (rv & HT_ENUMERATE_REMOVE) {
-                    he->next = todo;
-                    todo = he;
-                }
-            } else {
-                hep = &he->next;
-            }
-            if (rv & HT_ENUMERATE_STOP) {
-                goto out;
-            }
-        }
-    }
-
-out:
-    hep = &todo;
-    while ((he = *hep) != 0) {
-        PL_HashTableRawRemove(ht, hep, he);
-    }
-    return n;
-}
-
-#ifdef HASHMETER
-#include <math.h>
-#include <stdio.h>
-
-PR_IMPLEMENT(void)
-PL_HashTableDumpMeter(PLHashTable *ht, PLHashEnumerator dump, FILE *fp)
-{
-    double mean, variance;
-    PRUint32 nchains, nbuckets;
-    PRUint32 i, n, maxChain, maxChainLen;
-    PLHashEntry *he;
-
-    variance = 0;
-    nchains = 0;
-    maxChainLen = 0;
-    nbuckets = NBUCKETS(ht);
-    for (i = 0; i < nbuckets; i++) {
-        he = ht->buckets[i];
-        if (!he)
-            continue;
-        nchains++;
-        for (n = 0; he; he = he->next)
-            n++;
-        variance += n * n;
-        if (n > maxChainLen) {
-            maxChainLen = n;
-            maxChain = i;
-        }
-    }
-    mean = (double)ht->nentries / nchains;
-    variance = fabs(variance / nchains - mean * mean);
-
-    fprintf(fp, "\nHash table statistics:\n");
-    fprintf(fp, "     number of lookups: %u\n", ht->nlookups);
-    fprintf(fp, "     number of entries: %u\n", ht->nentries);
-    fprintf(fp, "       number of grows: %u\n", ht->ngrows);
-    fprintf(fp, "     number of shrinks: %u\n", ht->nshrinks);
-    fprintf(fp, "   mean steps per hash: %g\n", (double)ht->nsteps
-                                                / ht->nlookups);
-    fprintf(fp, "mean hash chain length: %g\n", mean);
-    fprintf(fp, "    standard deviation: %g\n", sqrt(variance));
-    fprintf(fp, " max hash chain length: %u\n", maxChainLen);
-    fprintf(fp, "        max hash chain: [%u]\n", maxChain);
-
-    for (he = ht->buckets[maxChain], i = 0; he; he = he->next, i++)
-        if ((*dump)(he, i, fp) != HT_ENUMERATE_NEXT)
-            break;
-}
-#endif /* HASHMETER */
-
-PR_IMPLEMENT(int)
-PL_HashTableDump(PLHashTable *ht, PLHashEnumerator dump, FILE *fp)
-{
-    int count;
-
-    count = PL_HashTableEnumerateEntries(ht, dump, fp);
-#ifdef HASHMETER
-    PL_HashTableDumpMeter(ht, dump, fp);
-#endif
-    return count;
-}
-
-PR_IMPLEMENT(PLHashNumber)
-PL_HashString(const void *key)
-{
-    PLHashNumber h;
-    const PRUint8 *s;
-
-    h = 0;
-    for (s = (const PRUint8*)key; *s; s++)
-        h = PR_ROTATE_LEFT32(h, 4) ^ *s;
-    return h;
-}
-
-PR_IMPLEMENT(int)
-PL_CompareStrings(const void *v1, const void *v2)
-{
-    return strcmp((const char*)v1, (const char*)v2) == 0;
-}
-
-PR_IMPLEMENT(int)
-PL_CompareValues(const void *v1, const void *v2)
-{
-    return v1 == v2;
-}