Mercurial > projects > ldc

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

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[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 6789050b5ad1
children 373489eeaf90
comparison
equal deleted inserted replaced
108:288fe1029e1f 109:5ab8e92611f9
49 * Reverse array of chars. 49 * Reverse array of chars.
50 * Handled separately because embedded multibyte encodings should not be 50 * Handled separately because embedded multibyte encodings should not be
51 * reversed. 51 * reversed.
52 */ 52 */
53 53
54 extern (C) long _adReverseChar(char[] a) 54 extern (C) char[] _adReverseChar(char[] a)
55 { 55 {
56 if (a.length > 1) 56 if (a.length > 1)
57 { 57 {
58 char[6] tmp; 58 char[6] tmp;
59 char[6] tmplo; 59 char[6] tmplo;
109 109
110 lo += stridehi; 110 lo += stridehi;
111 hi = hi - 1 + (stridehi - stridelo); 111 hi = hi - 1 + (stridehi - stridelo);
112 } 112 }
113 } 113 }
114 return *cast(long*)(&a); 114 return a;
115 } 115 }
116 116
117 unittest 117 unittest
118 { 118 {
119 string a = "abcd"; 119 string a = "abcd";
145 * Reverse array of wchars. 145 * Reverse array of wchars.
146 * Handled separately because embedded multiword encodings should not be 146 * Handled separately because embedded multiword encodings should not be
147 * reversed. 147 * reversed.
148 */ 148 */
149 149
150 extern (C) long _adReverseWchar(wchar[] a) 150 extern (C) wchar[] _adReverseWchar(wchar[] a)
151 { 151 {
152 if (a.length > 1) 152 if (a.length > 1)
153 { 153 {
154 wchar[2] tmp; 154 wchar[2] tmp;
155 wchar* lo = a.ptr; 155 wchar* lo = a.ptr;
203 203
204 lo += stridehi; 204 lo += stridehi;
205 hi = hi - 1 + (stridehi - stridelo); 205 hi = hi - 1 + (stridehi - stridelo);
206 } 206 }
207 } 207 }
208 return *cast(long*)(&a); 208 return a;
209 } 209 }
210 210
211 unittest 211 unittest
212 { 212 {
213 wstring a = "abcd"; 213 wstring a = "abcd";
228 228
229 /********************************************** 229 /**********************************************
230 * Support for array.reverse property. 230 * Support for array.reverse property.
231 */ 231 */
232 232
233 extern (C) long _adReverse(Array a, size_t szelem) 233 extern (C) Array _adReverse(Array a, size_t szelem)
234 out (result) 234 {
235 {
236 assert(result is *cast(long*)(&a));
237 }
238 body
239 {
240 if (a.length >= 2) 235 if (a.length >= 2)
241 { 236 {
242 byte* tmp; 237 byte* tmp;
243 byte[16] buffer; 238 byte[16] buffer;
244 239
270 // BUG: bad code is generate for delete pointer, tries 265 // BUG: bad code is generate for delete pointer, tries
271 // to call delclass. 266 // to call delclass.
272 //delete tmp; 267 //delete tmp;
273 } 268 }
274 } 269 }
275 return *cast(long*)(&a); 270 return a;
276 } 271 }
277 272
278 unittest 273 unittest
279 { 274 {
280 debug(adi) printf("array.reverse.unittest\n"); 275 debug(adi) printf("array.reverse.unittest\n");
281 276
362 357
363 /********************************************** 358 /**********************************************
364 * Sort array of chars. 359 * Sort array of chars.
365 */ 360 */
366 361
367 extern (C) long _adSortChar(char[] a) 362 extern (C) char[] _adSortChar(char[] a)
368 { 363 {
369 if (a.length > 1) 364 if (a.length > 1)
370 { 365 {
371 dstring da = toUTF32(a); 366 dstring da = toUTF32(a);
372 da.sort; 367 da.sort;
377 a[i .. i + t.length] = t[]; 372 a[i .. i + t.length] = t[];
378 i += t.length; 373 i += t.length;
379 } 374 }
380 delete da; 375 delete da;
381 } 376 }
382 return *cast(long*)(&a); 377 return a;
383 } 378 }
384 379
385 /********************************************** 380 /**********************************************
386 * Sort array of wchars. 381 * Sort array of wchars.
387 */ 382 */
388 383
389 extern (C) long _adSortWchar(wchar[] a) 384 extern (C) wchar[] _adSortWchar(wchar[] a)
390 { 385 {
391 if (a.length > 1) 386 if (a.length > 1)
392 { 387 {
393 dstring da = toUTF32(a); 388 dstring da = toUTF32(a);
394 da.sort; 389 da.sort;
399 a[i .. i + t.length] = t[]; 394 a[i .. i + t.length] = t[];
400 i += t.length; 395 i += t.length;
401 } 396 }
402 delete da; 397 delete da;
403 } 398 }
404 return *cast(long*)(&a); 399 return a;
405 } 400 }
406 401
407 /********************************************** 402 /**********************************************
408 * Support for array.sort property for bit[]. 403 * Support for array.sort property for bit[].
409 */ 404 */
801 assert(a == e); 796 assert(a == e);
802 assert(a <= e); 797 assert(a <= e);
803 assert(a >= e); 798 assert(a >= e);
804 } 799 }
805 } 800 }
801
802 /**********************************
803 * Support for array.dup property.
804 */
805
806 extern(C)
807 void* _d_realloc(void*, size_t);
808
809 extern(C)
810 Array _adDupT(TypeInfo ti, Array a)
811 {
812 Array r;
813 if (a.length)
814 {
815 auto sizeelem = ti.next.tsize(); // array element size
816 auto size = a.length * sizeelem;
817 r.ptr = _d_realloc(null,size);
818 r.length = a.length;
819 memcpy(r.ptr, a.ptr, size);
820 }
821 return r;
822 }
823
824 unittest
825 {
826 int[] a;
827 int[] b;
828 int i;
829
830 debug(adi) printf("array.dup.unittest\n");
831
832 a = new int[3];
833 a[0] = 1; a[1] = 2; a[2] = 3;
834 b = a.dup;
835 assert(b.length == 3);
836 for (i = 0; i < 3; i++)
837 assert(b[i] == i + 1);
838 }