/lphobos/internal/adi.d
D | 838 lines | 593 code | 137 blank | 108 comment | 104 complexity | 55769c771dce1930d734cf1443897ff4 MD5 | raw file
Possible License(s): BSD-3-Clause, AGPL-1.0
- //_ adi.d
- /**
- * Part of the D programming language runtime library.
- * Dynamic array property support routines
- */
- /*
- * Copyright (C) 2000-2006 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, in both source and binary form, 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.
- */
- //debug=adi; // uncomment to turn on debugging printf's
- //import std.stdio;
- import std.c.stdio;
- import std.c.stdlib;
- import std.c.string;
- //import std.string;
- import std.outofmemory;
- import std.utf;
- pragma(no_typeinfo)
- struct Array
- {
- size_t length;
- void* ptr;
- }
- /**********************************************
- * Reverse array of chars.
- * Handled separately because embedded multibyte encodings should not be
- * reversed.
- */
- extern (C) char[] _adReverseChar(char[] a)
- {
- if (a.length > 1)
- {
- char[6] tmp;
- char[6] tmplo;
- char* lo = a.ptr;
- char* hi = &a[length - 1];
- while (lo < hi)
- { auto clo = *lo;
- auto chi = *hi;
- //printf("lo = %d, hi = %d\n", lo, hi);
- if (clo <= 0x7F && chi <= 0x7F)
- {
- //printf("\tascii\n");
- *lo = chi;
- *hi = clo;
- lo++;
- hi--;
- continue;
- }
- uint stridelo = std.utf.UTF8stride[clo];
- uint stridehi = 1;
- while ((chi & 0xC0) == 0x80)
- {
- chi = *--hi;
- stridehi++;
- assert(hi >= lo);
- }
- if (lo == hi)
- break;
- //printf("\tstridelo = %d, stridehi = %d\n", stridelo, stridehi);
- if (stridelo == stridehi)
- {
- memcpy(tmp.ptr, lo, stridelo);
- memcpy(lo, hi, stridelo);
- memcpy(hi, tmp.ptr, stridelo);
- lo += stridelo;
- hi--;
- continue;
- }
- /* Shift the whole array. This is woefully inefficient
- */
- memcpy(tmp.ptr, hi, stridehi);
- memcpy(tmplo.ptr, lo, stridelo);
- memmove(lo + stridehi, lo + stridelo , (hi - lo) - stridelo);
- memcpy(lo, tmp.ptr, stridehi);
- memcpy(hi + stridehi - stridelo, tmplo.ptr, stridelo);
- lo += stridehi;
- hi = hi - 1 + (stridehi - stridelo);
- }
- }
- return a;
- }
- unittest
- {
- string a = "abcd";
- string r;
- r = a.dup.reverse;
- //writefln(r);
- assert(r == "dcba");
- a = "a\u1235\u1234c";
- //writefln(a);
- r = a.dup.reverse;
- //writefln(r);
- assert(r == "c\u1234\u1235a");
- a = "ab\u1234c";
- //writefln(a);
- r = a.dup.reverse;
- //writefln(r);
- assert(r == "c\u1234ba");
- a = "\u3026\u2021\u3061\n";
- r = a.dup.reverse;
- assert(r == "\n\u3061\u2021\u3026");
- }
- /**********************************************
- * Reverse array of wchars.
- * Handled separately because embedded multiword encodings should not be
- * reversed.
- */
- extern (C) wchar[] _adReverseWchar(wchar[] a)
- {
- if (a.length > 1)
- {
- wchar[2] tmp;
- wchar* lo = a.ptr;
- wchar* hi = &a[length - 1];
- while (lo < hi)
- { auto clo = *lo;
- auto chi = *hi;
- if ((clo < 0xD800 || clo > 0xDFFF) &&
- (chi < 0xD800 || chi > 0xDFFF))
- {
- *lo = chi;
- *hi = clo;
- lo++;
- hi--;
- continue;
- }
- int stridelo = 1 + (clo >= 0xD800 && clo <= 0xDBFF);
- int stridehi = 1;
- if (chi >= 0xDC00 && chi <= 0xDFFF)
- {
- chi = *--hi;
- stridehi++;
- assert(hi >= lo);
- }
- if (lo == hi)
- break;
- if (stridelo == stridehi)
- { int stmp;
- assert(stridelo == 2);
- assert(stmp.sizeof == 2 * (*lo).sizeof);
- stmp = *cast(int*)lo;
- *cast(int*)lo = *cast(int*)hi;
- *cast(int*)hi = stmp;
- lo += stridelo;
- hi--;
- continue;
- }
- /* Shift the whole array. This is woefully inefficient
- */
- memcpy(tmp.ptr, hi, stridehi * wchar.sizeof);
- memcpy(hi + stridehi - stridelo, lo, stridelo * wchar.sizeof);
- memmove(lo + stridehi, lo + stridelo , (hi - (lo + stridelo)) * wchar.sizeof);
- memcpy(lo, tmp.ptr, stridehi * wchar.sizeof);
- lo += stridehi;
- hi = hi - 1 + (stridehi - stridelo);
- }
- }
- return a;
- }
- unittest
- {
- wstring a = "abcd";
- wstring r;
- r = a.dup.reverse;
- assert(r == "dcba");
- a = "a\U00012356\U00012346c";
- r = a.dup.reverse;
- assert(r == "c\U00012346\U00012356a");
- a = "ab\U00012345c";
- r = a.dup.reverse;
- assert(r == "c\U00012345ba");
- }
- /**********************************************
- * Support for array.reverse property.
- */
- extern (C) Array _adReverse(Array a, size_t szelem)
- {
- if (a.length >= 2)
- {
- byte* tmp;
- byte[16] buffer;
- void* lo = a.ptr;
- void* hi = a.ptr + (a.length - 1) * szelem;
- tmp = buffer.ptr;
- if (szelem > 16)
- {
- //version (Win32)
- //tmp = cast(byte*) alloca(szelem);
- //else
- tmp = (new byte[szelem]).ptr;
- }
- for (; lo < hi; lo += szelem, hi -= szelem)
- {
- memcpy(tmp, lo, szelem);
- memcpy(lo, hi, szelem);
- memcpy(hi, tmp, szelem);
- }
- version (Win32)
- {
- }
- else
- {
- //if (szelem > 16)
- // BUG: bad code is generate for delete pointer, tries
- // to call delclass.
- //delete tmp;
- }
- }
- return a;
- }
- unittest
- {
- debug(adi) printf("array.reverse.unittest\n");
- int[] a = new int[5];
- int[] b;
- size_t i;
- for (i = 0; i < 5; i++)
- a[i] = i;
- b = a.reverse;
- assert(b is a);
- for (i = 0; i < 5; i++)
- assert(a[i] == 4 - i);
- struct X20
- { // More than 16 bytes in size
- int a;
- int b, c, d, e;
- }
- X20[] c = new X20[5];
- X20[] d;
- for (i = 0; i < 5; i++)
- { c[i].a = i;
- c[i].e = 10;
- }
- d = c.reverse;
- assert(d is c);
- for (i = 0; i < 5; i++)
- {
- assert(c[i].a == 4 - i);
- assert(c[i].e == 10);
- }
- }
- /**********************************************
- * Support for array.reverse property for bit[].
- */
- version (none)
- {
- extern (C) bit[] _adReverseBit(bit[] a)
- out (result)
- {
- assert(result is a);
- }
- body
- {
- if (a.length >= 2)
- {
- bit t;
- int lo, hi;
- lo = 0;
- hi = a.length - 1;
- for (; lo < hi; lo++, hi--)
- {
- t = a[lo];
- a[lo] = a[hi];
- a[hi] = t;
- }
- }
- return a;
- }
- unittest
- {
- debug(adi) printf("array.reverse_Bit[].unittest\n");
- bit[] b;
- b = new bit[5];
- static bit[5] data = [1,0,1,1,0];
- int i;
- b[] = data[];
- b.reverse;
- for (i = 0; i < 5; i++)
- {
- assert(b[i] == data[4 - i]);
- }
- }
- }
- /**********************************************
- * Sort array of chars.
- */
- extern (C) char[] _adSortChar(char[] a)
- {
- if (a.length > 1)
- {
- dstring da = toUTF32(a);
- da.sort;
- size_t i = 0;
- foreach (dchar d; da)
- { char[4] buf;
- string t = toUTF8(buf, d);
- a[i .. i + t.length] = t[];
- i += t.length;
- }
- delete da;
- }
- return a;
- }
- /**********************************************
- * Sort array of wchars.
- */
- extern (C) wchar[] _adSortWchar(wchar[] a)
- {
- if (a.length > 1)
- {
- dstring da = toUTF32(a);
- da.sort;
- size_t i = 0;
- foreach (dchar d; da)
- { wchar[2] buf;
- wstring t = toUTF16(buf, d);
- a[i .. i + t.length] = t[];
- i += t.length;
- }
- delete da;
- }
- return a;
- }
- /**********************************************
- * Support for array.sort property for bit[].
- */
- version (none)
- {
- extern (C) bit[] _adSortBit(bit[] a)
- out (result)
- {
- assert(result is a);
- }
- body
- {
- if (a.length >= 2)
- {
- size_t lo, hi;
- lo = 0;
- hi = a.length - 1;
- while (1)
- {
- while (1)
- {
- if (lo >= hi)
- goto Ldone;
- if (a[lo] == true)
- break;
- lo++;
- }
- while (1)
- {
- if (lo >= hi)
- goto Ldone;
- if (a[hi] == false)
- break;
- hi--;
- }
- a[lo] = false;
- a[hi] = true;
- lo++;
- hi--;
- }
- Ldone:
- ;
- }
- return a;
- }
- unittest
- {
- debug(adi) printf("array.sort_Bit[].unittest\n");
- }
- }
- /***************************************
- * Support for array equality test.
- */
- extern (C) int _adEq(Array a1, Array a2, TypeInfo ti)
- {
- // 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.next.tsize();
- auto p1 = a1.ptr;
- auto p2 = a2.ptr;
-
- /+
- for (int i = 0; i < a1.length; i++)
- {
- printf("%4x %4x\n", (cast(short*)p1)[i], (cast(short*)p2)[i]);
- }
- printf("sz = %u\n", sz);
- +/
- 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.next.equals(p1 + i * sz, p2 + i * sz))
- return 0; // not equal
- }
- return 1; // equal
- }
- unittest
- {
- debug(adi) printf("array.Eq unittest\n");
- string a = "hello";
- assert(a != "hel");
- assert(a != "helloo");
- assert(a != "betty");
- assert(a == "hello");
- assert(a != "hxxxx");
- }
- /***************************************
- * Support for bit array equality test for bit arrays.
- */
- version (none)
- {
- extern (C) int _adEqBit(Array a1, Array a2)
- { size_t i;
- if (a1.length != a2.length)
- return 0; // not equal
- auto p1 = cast(byte*)a1.ptr;
- auto p2 = cast(byte*)a2.ptr;
- auto n = a1.length / 8;
- for (i = 0; i < n; i++)
- {
- if (p1[i] != p2[i])
- return 0; // not equal
- }
- ubyte mask;
- n = a1.length & 7;
- mask = cast(ubyte)((1 << n) - 1);
- //printf("i = %d, n = %d, mask = %x, %x, %x\n", i, n, mask, p1[i], p2[i]);
- return (mask == 0) || (p1[i] & mask) == (p2[i] & mask);
- }
- unittest
- {
- debug(adi) printf("array.EqBit unittest\n");
- static bit[] a = [1,0,1,0,1];
- static bit[] b = [1,0,1];
- static bit[] c = [1,0,1,0,1,0,1];
- static bit[] d = [1,0,1,1,1];
- static bit[] e = [1,0,1,0,1];
- assert(a != b);
- assert(a != c);
- assert(a != d);
- assert(a == e);
- }
- }
- /***************************************
- * Support for array compare test.
- */
- extern (C) int _adCmp(Array a1, Array a2, TypeInfo ti)
- {
- //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;
- }
- unittest
- {
- debug(adi) printf("array.Cmp unittest\n");
- string a = "hello";
- 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");
- }
- /***************************************
- * Support for char array compare test.
- */
- extern (C) int _adCmpChar(Array a1, Array 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
- {
- int len;
- int c;
- //printf("adCmpChar()\n");
- len = a1.length;
- if (a2.length < len)
- len = a2.length;
- 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");
- string a = "hello";
- 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");
- }
- /***************************************
- * Support for bit array compare test.
- */
- version (none)
- {
- extern (C) int _adCmpBit(Array a1, Array a2)
- {
- int len;
- uint i;
- len = a1.length;
- if (a2.length < len)
- len = a2.length;
- ubyte *p1 = cast(ubyte*)a1.ptr;
- ubyte *p2 = cast(ubyte*)a2.ptr;
- uint n = len / 8;
- for (i = 0; i < n; i++)
- {
- if (p1[i] != p2[i])
- break; // not equal
- }
- for (uint j = i * 8; j < len; j++)
- { ubyte mask = cast(ubyte)(1 << j);
- int c;
- c = cast(int)(p1[i] & mask) - cast(int)(p2[i] & mask);
- if (c)
- return c;
- }
- return cast(int)a1.length - cast(int)a2.length;
- }
- unittest
- {
- debug(adi) printf("array.CmpBit unittest\n");
- static bit[] a = [1,0,1,0,1];
- static bit[] b = [1,0,1];
- static bit[] c = [1,0,1,0,1,0,1];
- static bit[] d = [1,0,1,1,1];
- static bit[] e = [1,0,1,0,1];
- assert(a > b);
- assert(a >= b);
- assert(a < c);
- assert(a <= c);
- assert(a < d);
- assert(a <= d);
- assert(a == e);
- assert(a <= e);
- assert(a >= e);
- }
- }
- /**********************************
- * Support for array.dup property.
- */
- extern(C)
- void* _d_realloc(void*, size_t);
- extern(C)
- Array _adDupT(TypeInfo ti, Array a)
- {
- Array r;
- if (a.length)
- {
- auto sizeelem = ti.next.tsize(); // array element size
- auto size = a.length * sizeelem;
- r.ptr = _d_realloc(null,size);
- r.length = a.length;
- memcpy(r.ptr, a.ptr, size);
- }
- return r;
- }
- unittest
- {
- int[] a;
- int[] b;
- int i;
- debug(adi) printf("array.dup.unittest\n");
- a = new int[3];
- a[0] = 1; a[1] = 2; a[2] = 3;
- b = a.dup;
- assert(b.length == 3);
- for (i = 0; i < 3; i++)
- assert(b[i] == i + 1);
- }