mirror of
https://github.com/autc04/Retro68.git
synced 2024-12-01 11:52:47 +00:00
333 lines
7.3 KiB
D
333 lines
7.3 KiB
D
/**
|
|
* Implementation of dynamic array property support routines.
|
|
*
|
|
* Copyright: Copyright Digital Mars 2000 - 2015.
|
|
* License: Distributed under the
|
|
* $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0).
|
|
* (See accompanying file LICENSE)
|
|
* Authors: Walter Bright
|
|
* Source: $(DRUNTIMESRC src/rt/_adi.d)
|
|
*/
|
|
|
|
module rt.adi;
|
|
|
|
//debug=adi; // uncomment to turn on debugging printf's
|
|
|
|
private
|
|
{
|
|
debug(adi) import core.stdc.stdio;
|
|
import core.stdc.string;
|
|
import core.stdc.stdlib;
|
|
import core.memory;
|
|
import rt.util.utf;
|
|
|
|
extern (C) void[] _adSort(void[] a, TypeInfo ti);
|
|
}
|
|
|
|
private dchar[] mallocUTF32(C)(in C[] s)
|
|
{
|
|
size_t j = 0;
|
|
auto p = cast(dchar*)malloc(dchar.sizeof * s.length);
|
|
auto r = p[0..s.length]; // r[] will never be longer than s[]
|
|
foreach (dchar c; s)
|
|
r[j++] = c;
|
|
return r[0 .. j];
|
|
}
|
|
|
|
/**********************************************
|
|
* Sort array of chars.
|
|
*/
|
|
|
|
extern (C) char[] _adSortChar(char[] a)
|
|
{
|
|
if (a.length > 1)
|
|
{
|
|
auto da = mallocUTF32(a);
|
|
_adSort(*cast(void[]*)&da, typeid(da[0]));
|
|
size_t i = 0;
|
|
foreach (dchar d; da)
|
|
{ char[4] buf;
|
|
auto t = toUTF8(buf, d);
|
|
a[i .. i + t.length] = t[];
|
|
i += t.length;
|
|
}
|
|
free(da.ptr);
|
|
}
|
|
return a;
|
|
}
|
|
|
|
/**********************************************
|
|
* Sort array of wchars.
|
|
*/
|
|
|
|
extern (C) wchar[] _adSortWchar(wchar[] a)
|
|
{
|
|
if (a.length > 1)
|
|
{
|
|
auto da = mallocUTF32(a);
|
|
_adSort(*cast(void[]*)&da, typeid(da[0]));
|
|
size_t i = 0;
|
|
foreach (dchar d; da)
|
|
{ wchar[2] buf;
|
|
auto t = toUTF16(buf, d);
|
|
a[i .. i + t.length] = t[];
|
|
i += t.length;
|
|
}
|
|
free(da.ptr);
|
|
}
|
|
return a;
|
|
}
|
|
|
|
/***************************************
|
|
* Support for array equality test.
|
|
* Returns:
|
|
* 1 equal
|
|
* 0 not equal
|
|
*/
|
|
|
|
extern (C) int _adEq(void[] a1, void[] a2, TypeInfo ti)
|
|
{
|
|
debug(adi) printf("_adEq(a1.length = %d, a2.length = %d)\n", a1.length, a2.length);
|
|
if (a1.length != a2.length)
|
|
return 0; // not equal
|
|
auto sz = ti.tsize;
|
|
auto p1 = a1.ptr;
|
|
auto p2 = a2.ptr;
|
|
|
|
if (sz == 1)
|
|
// We should really have a ti.isPOD() check for this
|
|
return (memcmp(p1, p2, a1.length) == 0);
|
|
|
|
for (size_t i = 0; i < a1.length; i++)
|
|
{
|
|
if (!ti.equals(p1 + i * sz, p2 + i * sz))
|
|
return 0; // not equal
|
|
}
|
|
return 1; // equal
|
|
}
|
|
|
|
extern (C) int _adEq2(void[] a1, void[] a2, TypeInfo ti)
|
|
{
|
|
debug(adi) printf("_adEq2(a1.length = %d, a2.length = %d)\n", a1.length, a2.length);
|
|
if (a1.length != a2.length)
|
|
return 0; // not equal
|
|
if (!ti.equals(&a1, &a2))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
unittest
|
|
{
|
|
debug(adi) printf("array.Eq unittest\n");
|
|
|
|
auto a = "hello"c;
|
|
|
|
assert(a != "hel");
|
|
assert(a != "helloo");
|
|
assert(a != "betty");
|
|
assert(a == "hello");
|
|
assert(a != "hxxxx");
|
|
|
|
float[] fa = [float.nan];
|
|
assert(fa != fa);
|
|
}
|
|
|
|
/***************************************
|
|
* Support for array compare test.
|
|
*/
|
|
|
|
extern (C) int _adCmp(void[] a1, void[] a2, TypeInfo ti)
|
|
{
|
|
debug(adi) printf("adCmp()\n");
|
|
auto len = a1.length;
|
|
if (a2.length < len)
|
|
len = a2.length;
|
|
auto sz = ti.tsize;
|
|
void *p1 = a1.ptr;
|
|
void *p2 = a2.ptr;
|
|
|
|
if (sz == 1)
|
|
{ // We should really have a ti.isPOD() check for this
|
|
auto c = memcmp(p1, p2, len);
|
|
if (c)
|
|
return c;
|
|
}
|
|
else
|
|
{
|
|
for (size_t i = 0; i < len; i++)
|
|
{
|
|
auto c = ti.compare(p1 + i * sz, p2 + i * sz);
|
|
if (c)
|
|
return c;
|
|
}
|
|
}
|
|
if (a1.length == a2.length)
|
|
return 0;
|
|
return (a1.length > a2.length) ? 1 : -1;
|
|
}
|
|
|
|
extern (C) int _adCmp2(void[] a1, void[] a2, TypeInfo ti)
|
|
{
|
|
debug(adi) printf("_adCmp2(a1.length = %d, a2.length = %d)\n", a1.length, a2.length);
|
|
return ti.compare(&a1, &a2);
|
|
}
|
|
unittest
|
|
{
|
|
debug(adi) printf("array.Cmp unittest\n");
|
|
|
|
auto a = "hello"c;
|
|
|
|
assert(a > "hel");
|
|
assert(a >= "hel");
|
|
assert(a < "helloo");
|
|
assert(a <= "helloo");
|
|
assert(a > "betty");
|
|
assert(a >= "betty");
|
|
assert(a == "hello");
|
|
assert(a <= "hello");
|
|
assert(a >= "hello");
|
|
assert(a < "я");
|
|
}
|
|
|
|
/***************************************
|
|
* Support for array compare test.
|
|
*/
|
|
|
|
extern (C) int _adCmpChar(void[] a1, void[] a2)
|
|
{
|
|
version (D_InlineAsm_X86)
|
|
{
|
|
asm
|
|
{ naked ;
|
|
|
|
push EDI ;
|
|
push ESI ;
|
|
|
|
mov ESI,a1+4[4+ESP] ;
|
|
mov EDI,a2+4[4+ESP] ;
|
|
|
|
mov ECX,a1[4+ESP] ;
|
|
mov EDX,a2[4+ESP] ;
|
|
|
|
cmp ECX,EDX ;
|
|
jb GotLength ;
|
|
|
|
mov ECX,EDX ;
|
|
|
|
GotLength:
|
|
cmp ECX,4 ;
|
|
jb DoBytes ;
|
|
|
|
// Do alignment if neither is dword aligned
|
|
test ESI,3 ;
|
|
jz Aligned ;
|
|
|
|
test EDI,3 ;
|
|
jz Aligned ;
|
|
DoAlign:
|
|
mov AL,[ESI] ; //align ESI to dword bounds
|
|
mov DL,[EDI] ;
|
|
|
|
cmp AL,DL ;
|
|
jnz Unequal ;
|
|
|
|
inc ESI ;
|
|
inc EDI ;
|
|
|
|
test ESI,3 ;
|
|
|
|
lea ECX,[ECX-1] ;
|
|
jnz DoAlign ;
|
|
Aligned:
|
|
mov EAX,ECX ;
|
|
|
|
// do multiple of 4 bytes at a time
|
|
|
|
shr ECX,2 ;
|
|
jz TryOdd ;
|
|
|
|
repe ;
|
|
cmpsd ;
|
|
|
|
jnz UnequalQuad ;
|
|
|
|
TryOdd:
|
|
mov ECX,EAX ;
|
|
DoBytes:
|
|
// if still equal and not end of string, do up to 3 bytes slightly
|
|
// slower.
|
|
|
|
and ECX,3 ;
|
|
jz Equal ;
|
|
|
|
repe ;
|
|
cmpsb ;
|
|
|
|
jnz Unequal ;
|
|
Equal:
|
|
mov EAX,a1[4+ESP] ;
|
|
mov EDX,a2[4+ESP] ;
|
|
|
|
sub EAX,EDX ;
|
|
pop ESI ;
|
|
|
|
pop EDI ;
|
|
ret ;
|
|
|
|
UnequalQuad:
|
|
mov EDX,[EDI-4] ;
|
|
mov EAX,[ESI-4] ;
|
|
|
|
cmp AL,DL ;
|
|
jnz Unequal ;
|
|
|
|
cmp AH,DH ;
|
|
jnz Unequal ;
|
|
|
|
shr EAX,16 ;
|
|
|
|
shr EDX,16 ;
|
|
|
|
cmp AL,DL ;
|
|
jnz Unequal ;
|
|
|
|
cmp AH,DH ;
|
|
Unequal:
|
|
sbb EAX,EAX ;
|
|
pop ESI ;
|
|
|
|
or EAX,1 ;
|
|
pop EDI ;
|
|
|
|
ret ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
debug(adi) printf("adCmpChar()\n");
|
|
auto len = a1.length;
|
|
if (a2.length < len)
|
|
len = a2.length;
|
|
auto c = memcmp(cast(char *)a1.ptr, cast(char *)a2.ptr, len);
|
|
if (!c)
|
|
c = cast(int)a1.length - cast(int)a2.length;
|
|
return c;
|
|
}
|
|
}
|
|
|
|
unittest
|
|
{
|
|
debug(adi) printf("array.CmpChar unittest\n");
|
|
|
|
auto a = "hello"c;
|
|
|
|
assert(a > "hel");
|
|
assert(a >= "hel");
|
|
assert(a < "helloo");
|
|
assert(a <= "helloo");
|
|
assert(a > "betty");
|
|
assert(a >= "betty");
|
|
assert(a == "hello");
|
|
assert(a <= "hello");
|
|
assert(a >= "hello");
|
|
}
|