projects/ldc: tango/lib/compiler/llvmdc/aaA.d comparison

comparison tango/lib/compiler/llvmdc/aaA.d @ 163:a8cd9bc1021a trunk

[svn r179] lots and lots of fixes, much more of tango now compiles/works.

author	lindquist
date	Mon, 05 May 2008 07:36:29 +0200
parents	1700239cab2e
children

comparison

equal deleted inserted replaced

-:1856c62af24b
+:a8cd9bc1021a
 *     distribution.
 */
 /*
 *  Modified by Sean Kelly <sean@f4.ca> for use with Tango.
+*  Modified by Tomas Lindquist Olsen <tomas@famolsen.dk> for use with LLVMDC.
 */
 private
 {
 import tango.stdc.stdarg;
 6291469UL,    25165843UL,
 100663319UL,  402653189UL,
 1610612741UL, 4294967291UL
 ];
-/* This is the type of the return value for dynamic arrays.
+// 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 long ArrayRet_t;
 struct Array
 {
 size_t length;
 void* ptr;
 }
 /* This is the type actually seen by the programmer, although
 * it is completely opaque.
 */
-struct AA
+// LLVMDC doesn't pass structs in registers so no need to wrap it ...
-{
+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_arg, TypeInfo keyti, size_t valuesize, void* pkey)
 in
 {
-assert(aa);
+assert(aa_arg);
 }
 out (result)
 {
 assert(result);
-assert(aa.a);
+assert(*aa_arg);
-assert(aa.a.b.length);
+assert((*aa_arg).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_arg)
-aa.a = new BB();
+*aa_arg = new BB();
+auto aa = *aa_arg;
-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) !is null)
 {
 if (key_hash == e.hash)
 {
 auto c = keyti.compare(pkey, e + 1);
 e = cast(aaA *) gc_calloc(size, bits);
 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);
+_aaRehash(aa_arg,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* _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 !is 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 !is 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) !is 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;
 /********************************************
 * Produce array of values from aa.
 */
-ArrayRet_t _aaValues(AA aa, size_t keysize, size_t valuesize)
+Array _aaValues(AA aa, size_t keysize, size_t valuesize)
 in
 {
 assert(keysize == aligntsize(keysize));
 }
 body
 }
 e = e.right;
 } while (e !is null);
 }
-if (aa.a)
+if (aa)
 {
 a.length = _aaLen(aa);
 a.ptr = cast(byte*) gc_malloc(a.length * valuesize,
 valuesize < (void*).sizeof &&
 valuesize > (void).sizeof  ? BlkAttr.NO_SCAN : 0);
 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.
 olde = left;
 }
 }
 //printf("Rehash\n");
-if (paa.a)
+if (*paa)
 {
-auto aa = paa.a;
+auto aa = *paa;
-auto len = _aaLen(*paa);
+auto len = _aaLen(aa);
 if (len)
 {   size_t i;
 for (i = 0; i < prime_list.length - 1; i++)
 {
 {
 if (e)
 _aaRehash_x(e);
 }
-newb.nodes = aa.nodes;
+newb.nodes = (*aa).nodes;
 }
-*paa.a = newb;
+**paa = newb;
 }
-return (*paa).a;
+return *paa;
 }
 /********************************************
 * Produce array of N byte keys from aa.
 */
-ArrayRet_t _aaKeys(AA aa, size_t keysize)
+Array _aaKeys(AA aa, size_t keysize)
 {
 byte[] res;
 size_t resi;
 void _aaKeys_x(aaA* e)
 } while (e !is null);
 }
 auto len = _aaLen(aa);
 if (!len)
-return 0;
+return Array();
 res = (cast(byte*) gc_malloc(len * keysize,
 keysize < (void*).sizeof &&
 keysize > (void).sizeof  ? BlkAttr.NO_SCAN : 0))[0 .. 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 tango/lib/compiler/llvmdc/aaA.d @ 163:a8cd9bc1021a trunk