/lphobos/internal/aaA.d
D | 825 lines | 534 code | 103 blank | 188 comment | 112 complexity | 70c22685c5f06d0e3e2961e9a3357f36 MD5 | raw file
Possible License(s): BSD-3-Clause, AGPL-1.0
- //_ aaA.d
- /**
- * Part of the D programming language runtime library.
- * Implementation of associative arrays.
- */
- /*
- * Copyright (C) 2000-2007 by Digital Mars, www.digitalmars.com
- * Written by Walter Bright
- *
- * This software is provided 'as-is', without any express or implied
- * warranty. In no event will the authors be held liable for any damages
- * arising from the use of this software.
- *
- * Permission is granted to anyone to use this software for any purpose,
- * including commercial applications, and to alter it and redistribute it
- * freely, subject to the following restrictions:
- *
- * o The origin of this software must not be misrepresented; you must not
- * claim that you wrote the original software. If you use this software
- * in a product, an acknowledgment in the product documentation would be
- * appreciated but is not required.
- * o Altered source versions must be plainly marked as such, and must not
- * be misrepresented as being the original software.
- * o This notice may not be removed or altered from any source
- * distribution.
- */
- /*
- * Modified for LDC by Tomas Lindquist Olsen.
- * The DMD implementation wont quite work due to the differences in how
- * structs are handled.
- */
- //import std.stdio;
- import std.c.stdarg;
- import std.c.stdio;
- import std.c.stdlib;
- import std.c.string;
- //import std.string;
- import std.outofmemory;
- // Auto-rehash and pre-allocate - Dave Fladebo
- static size_t[] prime_list = [
- 97UL, 389UL,
- 1543UL, 6151UL,
- 24593UL, 98317UL,
- 393241UL, 1572869UL,
- 6291469UL, 25165843UL,
- 100663319UL, 402653189UL,
- 1610612741UL, 4294967291UL
- ];
- /* This is the type of the return value for dynamic arrays.
- * It should be a type that is returned in registers.
- */
- alias Array ArrayRet_t;
- pragma(no_typeinfo)
- struct Array
- {
- size_t length;
- void* ptr;
- }
- pragma(no_typeinfo)
- struct aaA
- {
- aaA *left;
- aaA *right;
- hash_t hash;
- /* key */
- /* value */
- }
- pragma(no_typeinfo)
- struct BB
- {
- aaA*[] b;
- size_t nodes; // total number of aaA nodes
- }
- /* This is the type actually seen by the programmer, although
- * it is completely opaque.
- */
- alias BB* AA;
- /**********************************
- * Align to next pointer boundary, so that
- * GC won't be faced with misaligned pointers
- * in value.
- */
- size_t aligntsize(size_t tsize)
- {
- // Is pointer alignment on the x86-64 4 bytes or 8?
- //return (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
- return (tsize + 3) & (~3);
- }
- extern (C):
- /*************************************************
- * Invariant for aa.
- */
- /+
- void _aaInvAh(aaA*[] aa)
- {
- for (size_t i = 0; i < aa.length; i++)
- {
- if (aa[i])
- _aaInvAh_x(aa[i]);
- }
- }
- private int _aaCmpAh_x(aaA *e1, aaA *e2)
- { int c;
- c = e1.hash - e2.hash;
- if (c == 0)
- {
- c = e1.key.length - e2.key.length;
- if (c == 0)
- c = memcmp((char *)e1.key, (char *)e2.key, e1.key.length);
- }
- return c;
- }
- private void _aaInvAh_x(aaA *e)
- {
- hash_t key_hash;
- aaA *e1;
- aaA *e2;
- key_hash = getHash(e.key);
- assert(key_hash == e.hash);
- while (1)
- { int c;
- e1 = e.left;
- if (e1)
- {
- _aaInvAh_x(e1); // ordinary recursion
- do
- {
- c = _aaCmpAh_x(e1, e);
- assert(c < 0);
- e1 = e1.right;
- } while (e1 != null);
- }
- e2 = e.right;
- if (e2)
- {
- do
- {
- c = _aaCmpAh_x(e, e2);
- assert(c < 0);
- e2 = e2.left;
- } while (e2 != null);
- e = e.right; // tail recursion
- }
- else
- break;
- }
- }
- +/
- /****************************************************
- * Determine number of entries in associative array.
- */
- size_t _aaLen(AA aa)
- in
- {
- //printf("_aaLen()+\n");
- //_aaInv(aa);
- }
- out (result)
- {
- size_t len = 0;
- void _aaLen_x(aaA* ex)
- {
- auto e = ex;
- len++;
- while (1)
- {
- if (e.right)
- _aaLen_x(e.right);
- e = e.left;
- if (!e)
- break;
- len++;
- }
- }
- if (aa)
- {
- foreach (e; aa.b)
- {
- if (e)
- _aaLen_x(e);
- }
- }
- assert(len == result);
- //printf("_aaLen()-\n");
- }
- body
- {
- return aa ? aa.nodes : 0;
- }
- /*************************************************
- * Get pointer to value in associative array indexed by key.
- * Add entry for key if it is not already there.
- */
- void* _aaGet(AA* aa, TypeInfo keyti, size_t valuesize, void* pkey)
- in
- {
- assert(aa);
- }
- out (result)
- {
- assert(result);
- assert(*aa);
- assert((*aa).b.length);
- //assert(_aaInAh(*aa, key));
- }
- body
- {
- //auto pkey = cast(void *)(&valuesize + 1);
- size_t i;
- aaA* e;
- auto keysize = aligntsize(keyti.tsize());
- if (!*aa)
- *aa = new BB();
- if (!(*aa).b.length)
- {
- alias aaA *pa;
- auto len = prime_list[0];
- (*aa).b = new pa[len];
- }
- auto key_hash = keyti.getHash(pkey);
- //printf("hash = %d\n", key_hash);
- i = key_hash % (*aa).b.length;
- auto pe = &(*aa).b[i];
- while ((e = *pe) != null)
- {
- if (key_hash == e.hash)
- {
- auto c = keyti.compare(pkey, e + 1);
- if (c == 0)
- goto Lret;
- pe = (c < 0) ? &e.left : &e.right;
- }
- else
- pe = (key_hash < e.hash) ? &e.left : &e.right;
- }
- // Not found, create new elem
- //printf("create new one\n");
- e = cast(aaA *) cast(void*) new void[aaA.sizeof + keysize + valuesize];
- memcpy(e + 1, pkey, keysize);
- e.hash = key_hash;
- *pe = e;
- auto nodes = ++(*aa).nodes;
- //printf("length = %d, nodes = %d\n", (*aa).length, nodes);
- if (nodes > (*aa).b.length * 4)
- {
- _aaRehash(aa,keyti);
- }
- Lret:
- return cast(void *)(e + 1) + keysize;
- }
- /*************************************************
- * Get pointer to value in associative array indexed by key.
- * Returns null if it is not already there.
- */
- void* _aaGetRvalue(AA aa, TypeInfo keyti, size_t valuesize, void* pkey)
- {
- //printf("_aaGetRvalue(valuesize = %u)\n", valuesize);
- if (!aa)
- return null;
- //auto pkey = cast(void *)(&valuesize + 1);
- auto keysize = aligntsize(keyti.tsize());
- auto len = aa.b.length;
- if (len)
- {
- auto key_hash = keyti.getHash(pkey);
- //printf("hash = %d\n", key_hash);
- size_t i = key_hash % len;
- auto e = aa.b[i];
- while (e != null)
- {
- if (key_hash == e.hash)
- {
- auto c = keyti.compare(pkey, e + 1);
- if (c == 0)
- return cast(void *)(e + 1) + keysize;
- e = (c < 0) ? e.left : e.right;
- }
- else
- e = (key_hash < e.hash) ? e.left : e.right;
- }
- }
- return null; // not found, caller will throw exception
- }
- /*************************************************
- * Determine if key is in aa.
- * Returns:
- * null not in aa
- * !=null in aa, return pointer to value
- */
- void* _aaIn(AA aa, TypeInfo keyti, void* pkey)
- in
- {
- }
- out (result)
- {
- //assert(result == 0 || result == 1);
- }
- body
- {
- if (aa)
- {
- //auto pkey = cast(void *)(&keyti + 1);
- //printf("_aaIn(), .length = %d, .ptr = %x\n", aa.length, cast(uint)aa.ptr);
- auto len = aa.b.length;
- if (len)
- {
- auto key_hash = keyti.getHash(pkey);
- //printf("hash = %d\n", key_hash);
- size_t i = key_hash % len;
- auto e = aa.b[i];
- while (e != null)
- {
- if (key_hash == e.hash)
- {
- auto c = keyti.compare(pkey, e + 1);
- if (c == 0)
- return cast(void *)(e + 1) + aligntsize(keyti.tsize());
- e = (c < 0) ? e.left : e.right;
- }
- else
- e = (key_hash < e.hash) ? e.left : e.right;
- }
- }
- }
- // Not found
- return null;
- }
- /*************************************************
- * Delete key entry in aa[].
- * If key is not in aa[], do nothing.
- */
- void _aaDel(AA aa, TypeInfo keyti, void* pkey)
- {
- //auto pkey = cast(void *)(&keyti + 1);
- aaA* e;
- if (aa && aa.b.length)
- {
- auto key_hash = keyti.getHash(pkey);
- //printf("hash = %d\n", key_hash);
- size_t i = key_hash % aa.b.length;
- auto pe = &aa.b[i];
- while ((e = *pe) != null) // null means not found
- {
- if (key_hash == e.hash)
- {
- auto c = keyti.compare(pkey, e + 1);
- if (c == 0)
- {
- if (!e.left && !e.right)
- {
- *pe = null;
- }
- else if (e.left && !e.right)
- {
- *pe = e.left;
- e.left = null;
- }
- else if (!e.left && e.right)
- {
- *pe = e.right;
- e.right = null;
- }
- else
- {
- *pe = e.left;
- e.left = null;
- do
- pe = &(*pe).right;
- while (*pe);
- *pe = e.right;
- e.right = null;
- }
- aa.nodes--;
- // Should notify GC that e can be free'd now
- break;
- }
- pe = (c < 0) ? &e.left : &e.right;
- }
- else
- pe = (key_hash < e.hash) ? &e.left : &e.right;
- }
- }
- }
- /********************************************
- * Produce array of values from aa.
- */
- ArrayRet_t _aaValues(AA aa, size_t keysize, size_t valuesize)
- in
- {
- assert(keysize == aligntsize(keysize));
- }
- body
- {
- size_t resi;
- Array a;
- void _aaValues_x(aaA* e)
- {
- do
- {
- memcpy(a.ptr + resi * valuesize,
- cast(byte*)e + aaA.sizeof + keysize,
- valuesize);
- resi++;
- if (e.left)
- { if (!e.right)
- { e = e.left;
- continue;
- }
- _aaValues_x(e.left);
- }
- e = e.right;
- } while (e != null);
- }
- if (aa)
- {
- a.length = _aaLen(aa);
- a.ptr = (new void[a.length * valuesize]).ptr;
- resi = 0;
- foreach (e; aa.b)
- {
- if (e)
- _aaValues_x(e);
- }
- assert(resi == a.length);
- }
- return a;
- }
- /********************************************
- * Rehash an array.
- */
- void* _aaRehash(AA* paa, TypeInfo keyti)
- in
- {
- assert(paa);
- //_aaInvAh(paa);
- }
- out (result)
- {
- //_aaInvAh(result);
- }
- body
- {
- BB newb;
- void _aaRehash_x(aaA* olde)
- {
- while (1)
- {
- auto left = olde.left;
- auto right = olde.right;
- olde.left = null;
- olde.right = null;
- aaA* e;
- //printf("rehash %p\n", olde);
- auto key_hash = olde.hash;
- size_t i = key_hash % newb.b.length;
- auto pe = &newb.b[i];
- while ((e = *pe) != null)
- {
- //printf("\te = %p, e.left = %p, e.right = %p\n", e, e.left, e.right);
- assert(e.left != e);
- assert(e.right != e);
- if (key_hash == e.hash)
- {
- auto c = keyti.compare(olde + 1, e + 1);
- assert(c != 0);
- pe = (c < 0) ? &e.left : &e.right;
- }
- else
- pe = (key_hash < e.hash) ? &e.left : &e.right;
- }
- *pe = olde;
- if (right)
- {
- if (!left)
- { olde = right;
- continue;
- }
- _aaRehash_x(right);
- }
- if (!left)
- break;
- olde = left;
- }
- }
- //printf("Rehash\n");
- if (paa)
- {
- auto aa = *paa;
- auto len = _aaLen(*paa);
- if (len)
- { size_t i;
- for (i = 0; i < prime_list.length - 1; i++)
- {
- if (len <= prime_list[i])
- break;
- }
- len = prime_list[i];
- newb.b = new aaA*[len];
- foreach (e; aa.b)
- {
- if (e)
- _aaRehash_x(e);
- }
- newb.nodes = aa.nodes;
- }
- **paa = newb;
- }
- return *paa;
- }
- /********************************************
- * Produce array of N byte keys from aa.
- */
- ArrayRet_t _aaKeys(AA aa, size_t keysize)
- {
- byte[] res;
- size_t resi;
- void _aaKeys_x(aaA* e)
- {
- do
- {
- memcpy(&res[resi * keysize], cast(byte*)(e + 1), keysize);
- resi++;
- if (e.left)
- { if (!e.right)
- { e = e.left;
- continue;
- }
- _aaKeys_x(e.left);
- }
- e = e.right;
- } while (e != null);
- }
- auto len = _aaLen(aa);
- if (!len)
- return ArrayRet_t.init;
- res = cast(byte[])new void[len * keysize];
- resi = 0;
- foreach (e; aa.b)
- {
- if (e)
- _aaKeys_x(e);
- }
- assert(resi == len);
- return Array(len, res.ptr);
- }
- /**********************************************
- * 'apply' for associative arrays - to support foreach
- */
- // dg is D, but _aaApply() is C
- extern (D) typedef int delegate(void *) dg_t;
- int _aaApply(AA aa, size_t keysize, dg_t dg)
- in
- {
- assert(aligntsize(keysize) == keysize);
- }
- body
- { int result;
- //printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa, keysize, dg);
- int treewalker(aaA* e)
- { int result;
- do
- {
- //printf("treewalker(e = %p, dg = x%llx)\n", e, dg);
- result = dg(cast(void *)(e + 1) + keysize);
- if (result)
- break;
- if (e.right)
- { if (!e.left)
- {
- e = e.right;
- continue;
- }
- result = treewalker(e.right);
- if (result)
- break;
- }
- e = e.left;
- } while (e);
- return result;
- }
- if (aa)
- {
- foreach (e; aa.b)
- {
- if (e)
- {
- result = treewalker(e);
- if (result)
- break;
- }
- }
- }
- return result;
- }
- // dg is D, but _aaApply2() is C
- extern (D) typedef int delegate(void *, void *) dg2_t;
- int _aaApply2(AA aa, size_t keysize, dg2_t dg)
- in
- {
- assert(aligntsize(keysize) == keysize);
- }
- body
- { int result;
- //printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa, keysize, dg);
- int treewalker(aaA* e)
- { int result;
- do
- {
- //printf("treewalker(e = %p, dg = x%llx)\n", e, dg);
- result = dg(cast(void *)(e + 1), cast(void *)(e + 1) + keysize);
- if (result)
- break;
- if (e.right)
- { if (!e.left)
- {
- e = e.right;
- continue;
- }
- result = treewalker(e.right);
- if (result)
- break;
- }
- e = e.left;
- } while (e);
- return result;
- }
- if (aa)
- {
- foreach (e; aa.b)
- {
- if (e)
- {
- result = treewalker(e);
- if (result)
- break;
- }
- }
- }
- return result;
- }
- /***********************************
- * Construct an associative array of type ti from
- * length pairs of key/value pairs.
- */
- version(none) // not used, C variadics can't be implemented in LLVM on x86-64
- {
- BB* _d_assocarrayliteralT(TypeInfo_AssociativeArray ti, size_t length, ...)
- {
- auto valuesize = ti.next.tsize(); // value size
- auto keyti = ti.key;
- auto keysize = keyti.tsize(); // key size
- BB* result;
- //printf("_d_assocarrayliteralT(keysize = %d, valuesize = %d, length = %d)\n", keysize, valuesize, length);
- //writefln("tivalue = %s", ti.next.classinfo.name);
- if (length == 0 || valuesize == 0 || keysize == 0)
- {
- ;
- }
- else
- {
- va_list q;
- va_start!(size_t)(q, length);
- result = new BB();
- size_t i;
- for (i = 0; i < prime_list.length - 1; i++)
- {
- if (length <= prime_list[i])
- break;
- }
- auto len = prime_list[i];
- result.b = new aaA*[len];
- size_t keystacksize = (keysize + int.sizeof - 1) & ~(int.sizeof - 1);
- size_t valuestacksize = (valuesize + int.sizeof - 1) & ~(int.sizeof - 1);
- size_t keytsize = aligntsize(keysize);
- for (size_t j = 0; j < length; j++)
- { void* pkey = q;
- q += keystacksize;
- void* pvalue = q;
- q += valuestacksize;
- aaA* e;
- auto key_hash = keyti.getHash(pkey);
- //printf("hash = %d\n", key_hash);
- i = key_hash % len;
- auto pe = &result.b[i];
- while (1)
- {
- e = *pe;
- if (!e)
- {
- // Not found, create new elem
- //printf("create new one\n");
- e = cast(aaA *) cast(void*) new void[aaA.sizeof + keytsize + valuesize];
- memcpy(e + 1, pkey, keysize);
- e.hash = key_hash;
- *pe = e;
- result.nodes++;
- break;
- }
- if (key_hash == e.hash)
- {
- auto c = keyti.compare(pkey, e + 1);
- if (c == 0)
- break;
- pe = (c < 0) ? &e.left : &e.right;
- }
- else
- pe = (key_hash < e.hash) ? &e.left : &e.right;
- }
- memcpy(cast(void *)(e + 1) + keytsize, pvalue, valuesize);
- }
- va_end(q);
- }
- return result;
- }
- }