projects/ldc: lphobos/internal/aaA.d comparison

comparison lphobos/internal/aaA.d @ 109:5ab8e92611f9 trunk

[svn r113] Added initial support for associative arrays (AAs). Fixed some problems with the string runtime support functions. Fixed initialization of array of structs. Fixed slice assignment where LHS is slice but RHS is dynamic array. Fixed problems with result of assignment expressions. Fixed foreach problems with key type mismatches.

author	lindquist
date	Wed, 21 Nov 2007 04:13:15 +0100
parents	288fe1029e1f
children	facc562f5674

comparison

equal deleted inserted replaced

-:288fe1029e1f
+:5ab8e92611f9
 *     be misrepresented as being the original software.
 *  o  This notice may not be removed or altered from any source
 *     distribution.
 */
+/*
+* Modified for LLVMDC 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.string;
 import std.outofmemory;
 // Auto-rehash and pre-allocate - Dave Fladebo
 1610612741UL, 4294967291UL
 ];
 /* This is the type of the return value for dynamic arrays.
 * It should be a type that is returned in registers.
-* Although DMD will return types of Array in registers,
+*/
-* gcc will not, so we instead use a 'long'.
+alias Array ArrayRet_t;
-*/
-alias long ArrayRet_t;
+pragma(LLVM_internal, "notypeinfo")
 struct Array
 {
 size_t length;
 void* ptr;
 }
+pragma(LLVM_internal, "notypeinfo")
 struct aaA
 {
 aaA *left;
 aaA *right;
 hash_t hash;
 /* key   */
 /* value */
 }
+pragma(LLVM_internal, "notypeinfo")
 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.
 */
-struct AA
+alias BB* AA;
-{
-BB* a;
-}
 /**********************************
 * Align to next pointer boundary, so that
 * GC won't be faced with misaligned pointers
 * in value.
 		    break;
 		len++;
 	    }
 	}
-	if (aa.a)
+	if (aa)
 	{
-	    foreach (e; aa.a.b)
+	    foreach (e; aa.b)
 	    {
 		if (e)
 		    _aaLen_x(e);
 	    }
 	}
 	//printf("_aaLen()-\n");
 }
 body
 {
-	return aa.a ? aa.a.nodes : 0;
+	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* _aaGet(AA* aa, TypeInfo keyti, void* pkey, size_t valuesize)
 in
 {
 	assert(aa);
 }
 out (result)
 {
 	assert(result);
-	assert(aa.a);
+	assert(*aa);
-	assert(aa.a.b.length);
+	assert((*aa).b.length);
-	//assert(_aaInAh(*aa.a, key));
+	//assert(_aaInAh(*aa, key));
 }
 body
 {
-	auto pkey = cast(void *)(&valuesize + 1);
+	//auto pkey = cast(void *)(&valuesize + 1);
 	size_t i;
 	aaA* e;
 	auto keysize = aligntsize(keyti.tsize());
-	if (!aa.a)
+	if (!*aa)
-	    aa.a = new BB();
+	    *aa = new BB();
-	if (!aa.a.b.length)
+	if (!(*aa).b.length)
 	{
 	    alias aaA *pa;
 	    auto len = prime_list[0];
-	    aa.a.b = new pa[len];
+	    (*aa).b = new pa[len];
 	}
 	auto key_hash = keyti.getHash(pkey);
 	//printf("hash = %d\n", key_hash);
-	i = key_hash % aa.a.b.length;
+	i = key_hash % (*aa).b.length;
-	auto pe = &aa.a.b[i];
+	auto pe = &(*aa).b[i];
 	while ((e = *pe) != null)
 	{
 	    if (key_hash == e.hash)
 	    {
 		auto c = keyti.compare(pkey, e + 1);
 	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.a.nodes;
+	auto nodes = ++(*aa).nodes;
-	//printf("length = %d, nodes = %d\n", (*aa.a).length, nodes);
+	//printf("length = %d, nodes = %d\n", (*aa).length, nodes);
-	if (nodes > aa.a.b.length * 4)
+	if (nodes > (*aa).b.length * 4)
 	{
 	    _aaRehash(aa,keyti);
 	}
 Lret:
 /*************************************************
 * 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* _aaGetRvalue(AA aa, TypeInfo keyti, size_t valuesize, void* pkey)
 {
 	//printf("_aaGetRvalue(valuesize = %u)\n", valuesize);
-	if (!aa.a)
+	if (!aa)
 	    return null;
-	auto pkey = cast(void *)(&valuesize + 1);
+	//auto pkey = cast(void *)(&valuesize + 1);
 	auto keysize = aligntsize(keyti.tsize());
-	auto len = aa.a.b.length;
+	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.a.b[i];
+	    auto e = aa.b[i];
 	    while (e != null)
 	    {
 		if (key_hash == e.hash)
 		{
 		    auto c = keyti.compare(pkey, e + 1);
 * Returns:
 *	null	not in aa
 *	!=null	in aa, return pointer to value
 */
-void* _aaIn(AA aa, TypeInfo keyti, ...)
+void* _aaIn(AA aa, TypeInfo keyti, void* pkey)
 in
 {
 }
 out (result)
 {
 	//assert(result == 0 || result == 1);
 }
 body
 {
-	if (aa.a)
+	if (aa)
 	{
-	    auto pkey = cast(void *)(&keyti + 1);
+	    //auto pkey = cast(void *)(&keyti + 1);
-	    //printf("_aaIn(), .length = %d, .ptr = %x\n", aa.a.length, cast(uint)aa.a.ptr);
+	    //printf("_aaIn(), .length = %d, .ptr = %x\n", aa.length, cast(uint)aa.ptr);
-	    auto len = aa.a.b.length;
+	    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.a.b[i];
+		auto e = aa.b[i];
 		while (e != null)
 		{
 		    if (key_hash == e.hash)
 		    {
 			auto c = keyti.compare(pkey, e + 1);
 /*************************************************
 * Delete key entry in aa[].
 * If key is not in aa[], do nothing.
 */
-void _aaDel(AA aa, TypeInfo keyti, ...)
+void _aaDel(AA aa, TypeInfo keyti, void* pkey)
 {
-	auto pkey = cast(void *)(&keyti + 1);
+	//auto pkey = cast(void *)(&keyti + 1);
 	aaA* e;
-	if (aa.a && aa.a.b.length)
+	if (aa && aa.b.length)
 	{
 	    auto key_hash = keyti.getHash(pkey);
 	    //printf("hash = %d\n", key_hash);
-	    size_t i = key_hash % aa.a.b.length;
+	    size_t i = key_hash % aa.b.length;
-	    auto pe = &aa.a.b[i];
+	    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);
 			    while (*pe);
 			    *pe = e.right;
 			    e.right = null;
 			}
-			aa.a.nodes--;
+			aa.nodes--;
 			// Should notify GC that e can be free'd now
 			break;
 		    }
 		    pe = (c < 0) ? &e.left : &e.right;
 		}
 		e = e.right;
 	    } while (e != null);
 	}
-	if (aa.a)
+	if (aa)
 	{
 	    a.length = _aaLen(aa);
 	    a.ptr = (new void[a.length * valuesize]).ptr;
 	    resi = 0;
-	    foreach (e; aa.a.b)
+	    foreach (e; aa.b)
 	    {
 		if (e)
 		    _aaValues_x(e);
 	    }
 	    assert(resi == a.length);
 	}
-	return *cast(ArrayRet_t*)(&a);
+	return a;
 }
 /********************************************
 * Rehash an array.
 */
 void* _aaRehash(AA* paa, TypeInfo keyti)
 in
 {
+assert(paa);
 	//_aaInvAh(paa);
 }
 out (result)
 {
 	//_aaInvAh(result);
 		olde = left;
 	    }
 	}
 	//printf("Rehash\n");
-	if (paa.a)
+	if (paa)
 	{
-	    auto aa = paa.a;
+	    auto aa = *paa;
 	    auto len = _aaLen(*paa);
 	    if (len)
 	    {   size_t i;
 		for (i = 0; i < prime_list.length - 1; i++)
 		}
 		newb.nodes = aa.nodes;
 	    }
-	    *paa.a = newb;
+	    **paa = newb;
 	}
-	return (*paa).a;
+	return *paa;
 }
 /********************************************
 * Produce array of N byte keys from aa.
 	    } while (e != null);
 	}
 	auto len = _aaLen(aa);
 	if (!len)
-	    return 0;
+	    return ArrayRet_t.init;
 	res = cast(byte[])new void[len * keysize];
 	resi = 0;
-	foreach (e; aa.a.b)
+	foreach (e; aa.b)
 	{
 	    if (e)
 		_aaKeys_x(e);
 	}
 	assert(resi == len);
-	Array a;
+	return Array(len, res.ptr);
-	a.length = len;
-	a.ptr = res.ptr;
-	return *cast(ArrayRet_t*)(&a);
 }
 /**********************************************
 * 'apply' for associative arrays - to support foreach
 assert(aligntsize(keysize) == keysize);
 }
 body
 {   int result;
-//printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa.a, keysize, dg);
+//printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa, keysize, dg);
 int treewalker(aaA* e)
 {	int result;
 	do
 	} while (e);
 	return result;
 }
-if (aa.a)
+if (aa)
 {
-	foreach (e; aa.a.b)
+	foreach (e; aa.b)
 	{
 	    if (e)
 	    {
 		result = treewalker(e);
 		if (result)
 assert(aligntsize(keysize) == keysize);
 }
 body
 {   int result;
-//printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa.a, keysize, dg);
+//printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa, keysize, dg);
 int treewalker(aaA* e)
 {	int result;
 	do
 	} while (e);
 	return result;
 }
-if (aa.a)
+if (aa)
 {
-	foreach (e; aa.a.b)
+	foreach (e; aa.b)
 	{
 	    if (e)
 	    {
 		result = treewalker(e);
 		if (result)

Mercurial > projects > ldc

comparison lphobos/internal/aaA.d @ 109:5ab8e92611f9 trunk