Skip to content
This repository has been archived by the owner on Oct 12, 2022. It is now read-only.

[dmd-cxx] object: Declare private struct AA and fix aaA function signatures #2572

Merged
merged 1 commit into from
Apr 22, 2019
Merged

[dmd-cxx] object: Declare private struct AA and fix aaA function signatures #2572

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
97 changes: 67 additions & 30 deletions src/object.d
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -661,12 +661,12 @@ class TypeInfo_AssociativeArray : TypeInfo

override bool equals(in void* p1, in void* p2) @trusted const
{
return !!_aaEqual(this, *cast(const void**) p1, *cast(const void**) p2);
return !!_aaEqual(this, *cast(const AA*) p1, *cast(const AA*) p2);
}

override hash_t getHash(scope const void* p) nothrow @trusted const
{
return _aaGetHash(cast(void*)p, this);
return _aaGetHash(cast(AA*)p, this);
}

// BUG: need to add the rest of the functions
Expand Down Expand Up @@ -1848,30 +1848,31 @@ extern (C)
{
// from druntime/src/rt/aaA.d

// size_t _aaLen(in void* p) pure nothrow @nogc;
private void* _aaGetY(void** paa, const TypeInfo_AssociativeArray ti, in size_t valuesize, in void* pkey) pure nothrow;
private void* _aaGetX(void** paa, const TypeInfo_AssociativeArray ti, in size_t valuesize, in void* pkey, out bool found) pure nothrow;
// inout(void)* _aaGetRvalueX(inout void* p, in TypeInfo keyti, in size_t valuesize, in void* pkey);
inout(void)[] _aaValues(inout void* p, in size_t keysize, in size_t valuesize, const TypeInfo tiValArray) pure nothrow;
inout(void)[] _aaKeys(inout void* p, in size_t keysize, const TypeInfo tiKeyArray) pure nothrow;
void* _aaRehash(void** pp, in TypeInfo keyti) pure nothrow;
void _aaClear(void* p) pure nothrow;
private struct AA { void* impl; }
// size_t _aaLen(in AA aa) pure nothrow @nogc;
private void* _aaGetY(AA* paa, const TypeInfo_AssociativeArray ti, in size_t valsz, in void* pkey) pure nothrow;
private void* _aaGetX(AA* paa, const TypeInfo_AssociativeArray ti, in size_t valsz, in void* pkey, out bool found) pure nothrow;
// inout(void)* _aaGetRvalueX(inout AA aa, in TypeInfo keyti, in size_t valsz, in void* pkey);
inout(void[]) _aaValues(inout AA aa, in size_t keysz, in size_t valsz, const TypeInfo tiValueArray) pure nothrow;
inout(void[]) _aaKeys(inout AA aa, in size_t keysz, const TypeInfo tiKeyArray) pure nothrow;
void* _aaRehash(AA* paa, in TypeInfo keyti) pure nothrow;
void _aaClear(AA aa) pure nothrow;

// alias _dg_t = extern(D) int delegate(void*);
// int _aaApply(void* aa, size_t keysize, _dg_t dg);
// int _aaApply(AA aa, size_t keysize, _dg_t dg);

// alias _dg2_t = extern(D) int delegate(void*, void*);
// int _aaApply2(void* aa, size_t keysize, _dg2_t dg);
// int _aaApply2(AA aa, size_t keysize, _dg2_t dg);

private struct AARange { void* impl; size_t idx; }
AARange _aaRange(void* aa) pure nothrow @nogc @safe;
private struct AARange { AA impl; size_t idx; }
AARange _aaRange(AA aa) pure nothrow @nogc @safe;
bool _aaRangeEmpty(AARange r) pure nothrow @nogc @safe;
void* _aaRangeFrontKey(AARange r) pure nothrow @nogc @safe;
void* _aaRangeFrontValue(AARange r) pure nothrow @nogc @safe;
void _aaRangePopFront(ref AARange r) pure nothrow @nogc @safe;

int _aaEqual(in TypeInfo tiRaw, in void* e1, in void* e2);
hash_t _aaGetHash(in void* aa, in TypeInfo tiRaw) nothrow;
int _aaEqual(in TypeInfo tiRaw, in AA aa1, in AA aa2);
hash_t _aaGetHash(in AA* aa, in TypeInfo tiRaw) nothrow;

/*
_d_assocarrayliteralTX marked as pure, because aaLiteral can be called from pure code.
Expand All @@ -1896,13 +1897,13 @@ alias AssociativeArray(Key, Value) = Value[Key];
*/
void clear(T : Value[Key], Value, Key)(T aa)
{
_aaClear(*cast(void **) &aa);
_aaClear(*cast(AA *) &aa);
}

/* ditto */
void clear(T : Value[Key], Value, Key)(T* aa)
{
_aaClear(*cast(void **) aa);
_aaClear(*cast(AA *) aa);
}

/***********************************
Expand All @@ -1915,28 +1916,28 @@ void clear(T : Value[Key], Value, Key)(T* aa)
*/
T rehash(T : Value[Key], Value, Key)(T aa)
{
_aaRehash(cast(void**)&aa, typeid(Value[Key]));
_aaRehash(cast(AA*)&aa, typeid(Value[Key]));
return aa;
}

/* ditto */
T rehash(T : Value[Key], Value, Key)(T* aa)
{
_aaRehash(cast(void**)aa, typeid(Value[Key]));
_aaRehash(cast(AA*)aa, typeid(Value[Key]));
return *aa;
}

/* ditto */
T rehash(T : shared Value[Key], Value, Key)(T aa)
{
_aaRehash(cast(void**)&aa, typeid(Value[Key]));
_aaRehash(cast(AA*)&aa, typeid(Value[Key]));
return aa;
}

/* ditto */
T rehash(T : shared Value[Key], Value, Key)(T* aa)
{
_aaRehash(cast(void**)aa, typeid(Value[Key]));
_aaRehash(cast(AA*)aa, typeid(Value[Key]));
return *aa;
}

Expand All @@ -1963,7 +1964,7 @@ V[K] dup(T : V[K], K, V)(T aa)
{
import core.stdc.string : memcpy;

void* pv = _aaGetY(cast(void**)&result, typeid(V[K]), V.sizeof, &k);
void* pv = _aaGetY(cast(AA*)&result, typeid(V[K]), V.sizeof, &k);
memcpy(pv, &v, V.sizeof);
return *cast(V*)pv;
}
Expand Down Expand Up @@ -1996,7 +1997,7 @@ private AARange _aaToRange(T: V[K], K, V)(ref T aa) pure nothrow @nogc @safe
alias realAA = aa;
else
const(V[K]) realAA = aa;
return _aaRange(() @trusted { return cast(void*)realAA; } ());
return _aaRange(() @trusted { return *cast(AA*)&realAA; } ());
}

/***********************************
Expand Down Expand Up @@ -2132,7 +2133,12 @@ auto byKeyValue(T : V[K], K, V)(T* aa) pure nothrow @nogc
*/
Key[] keys(T : Value[Key], Value, Key)(T aa) @property
{
auto a = cast(void[])_aaKeys(cast(inout(void)*)aa, Key.sizeof, typeid(Key[]));
// ensure we are dealing with a genuine AA.
static if (is(const(Value[Key]) == const(T)))
alias realAA = aa;
else
const(Value[Key]) realAA = aa;
auto a = cast(void[])_aaKeys(*cast(inout(AA)*)&realAA, Key.sizeof, typeid(Key[]));
auto res = *cast(Key[]*)&a;
_doPostblit(res);
return res;
Expand All @@ -2144,6 +2150,19 @@ Key[] keys(T : Value[Key], Value, Key)(T *aa) @property
return (*aa).keys;
}

@system unittest
{
static struct S
{
string str;
void[][string] dict;
alias dict this;
}

auto s = S("a");
assert(s.keys.length == 0);
}

/***********************************
* Returns a dynamic array, the elements of which are the values in the
* associative array.
Expand All @@ -2154,7 +2173,12 @@ Key[] keys(T : Value[Key], Value, Key)(T *aa) @property
*/
Value[] values(T : Value[Key], Value, Key)(T aa) @property
{
auto a = cast(void[])_aaValues(cast(inout(void)*)aa, Key.sizeof, Value.sizeof, typeid(Value[]));
// ensure we are dealing with a genuine AA.
static if (is(const(Value[Key]) == const(T)))
alias realAA = aa;
else
const(Value[Key]) realAA = aa;
auto a = cast(void[])_aaValues(*cast(inout(AA)*)&realAA, Key.sizeof, Value.sizeof, typeid(Value[]));
auto res = *cast(Value[]*)&a;
_doPostblit(res);
return res;
Expand All @@ -2166,6 +2190,19 @@ Value[] values(T : Value[Key], Value, Key)(T *aa) @property
return (*aa).values;
}

@system unittest
{
static struct S
{
string str;
void[][string] dict;
alias dict this;
}

auto s = S("a");
assert(s.values.length == 0);
}

/***********************************
* Looks up key; if it exists returns corresponding value else evaluates and
* returns defaultValue.
Expand Down Expand Up @@ -2206,12 +2243,12 @@ ref V require(K, V)(ref V[K] aa, K key, lazy V value = V.init)
{
auto p = () @trusted
{
return cast(V*) _aaGetX(cast(void**) &aa, typeid(V[K]), V.sizeof, &key, found);
return cast(V*) _aaGetX(cast(AA*) &aa, typeid(V[K]), V.sizeof, &key, found);
} ();
}
else
{
auto p = cast(V*) _aaGetX(cast(void**) &aa, typeid(V[K]), V.sizeof, &key, found);
auto p = cast(V*) _aaGetX(cast(AA*) &aa, typeid(V[K]), V.sizeof, &key, found);
}
return found ? *p : (*p = value);
}
Expand Down Expand Up @@ -2262,12 +2299,12 @@ if (isCreateOperation!(C, V) && isUpdateOperation!(U, V))
{
auto p = () @trusted
{
return cast(V*) _aaGetX(cast(void**) &aa, typeid(V[K]), V.sizeof, &key, found);
return cast(V*) _aaGetX(cast(AA*) &aa, typeid(V[K]), V.sizeof, &key, found);
} ();
}
else
{
auto p = cast(V*) _aaGetX(cast(void**) &aa, typeid(V[K]), V.sizeof, &key, found);
auto p = cast(V*) _aaGetX(cast(AA*) &aa, typeid(V[K]), V.sizeof, &key, found);
}
if (!found)
*p = create();
Expand Down