Mercurial > projects > dstress
changeset 1628:c6ef09dfba4d
add mini test set from ldc project
line wrap: on
line diff
--- a/Makefile Thu Jan 06 16:03:25 2011 +0100 +++ b/Makefile Mon Jan 10 19:47:18 2011 +0100 @@ -147,7 +147,7 @@ # nocompile : $(dstress__) nocompile_clean echo '#!/bin/sh' > nocompile.sh - find nocompile -type f | grep -v ".svn" | sort -f | xargs -n 1 echo "$(dstress__) torture-nocompile" >> nocompile.sh + find nocompile -type f | grep -v ".svn" | sort -f | xargs -n 1 echo "$(dstress__) nocompile" >> nocompile.sh chmod +x nocompile.sh ./nocompile.sh 2>> $(LOG) @@ -177,7 +177,7 @@ # compile : $(dstress__) compile_clean echo '#!/bin/sh' > compile.sh - find compile -type f | grep -v ".svn" | sort -f | xargs -n 1 echo "$(dstress__) torture-compile" >> compile.sh + find compile -type f | grep -v ".svn" | sort -f | xargs -n 1 echo "$(dstress__) compile" >> compile.sh chmod +x compile.sh ./compile.sh 2>> $(LOG) @@ -205,7 +205,7 @@ # run : $(dstress__) run_clean echo '#!/bin/sh' > run.sh - find run -type f | grep -v ".svn" | sort -f | xargs -n 1 echo "$(dstress__) torture-run" >> run.sh + find run -type f -name "*\\.d" | grep -v ".svn" | sort -f | xargs -n 1 echo "$(dstress__) run" >> run.sh chmod +x run.sh ./run.sh 2>> $(LOG) @@ -274,7 +274,7 @@ # norun : $(dstress__) norun_clean echo '#!/bin/sh' > norun.sh - find norun -type f | grep -v ".svn" | sort -f | xargs -n 1 echo "$(dstress__) torture-norun" >> norun.sh + find norun -type f -name "*\\.d" | grep -v ".svn" | sort -f | xargs -n 1 echo "$(dstress__) norun" >> norun.sh chmod +x norun.sh ./norun.sh 2>> $(LOG)
--- a/dstress.c Thu Jan 06 16:03:25 2011 +0100 +++ b/dstress.c Mon Jan 10 19:47:18 2011 +0100 @@ -157,7 +157,7 @@ #define TORTURE_PREFIX "torture-" #ifdef USE_POSIX -#define CRASH_RUN "./crashRun 30 1000" +#define CRASH_RUN "./crashRun 10 256" #ifdef USE_VALGRIND #define VALGRIND "valgrind --leak-check=no -q --suppressions=valgrind.suppress" #else
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/__asm1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,22 @@ +import ldc.llvmasm; +void main() { + version(X86) + { + int i; + __asm("movl $1, $0", "=*m,i", &i, 42); + assert(i == 42); + + int j = __asm!(int)("movl $1, %eax", "={ax},i", 42); + assert(j == 42); + + auto k = __asmtuple!(int,int)("mov $2, %eax ; mov $3, %edx", "={ax},={dx},i,i", 10, 20); + assert(k.v[0] == 10); + assert(k.v[1] == 20); + } + else version(PPC) + { + int j = 42; + int i = __asm!(int)("li $1, $0", "=r,*m", &j); + assert(i == 42); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/a.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,23 @@ +module a; + +extern(C) int printf(char*, ...); + +int i = 42; + +void main() +{ + int j; + j = i; + int* p; + p = &j; + int k = *p; + assert(k == 42); + + byte b = -1; + int i = b; + assert(i == -1); + + int* p2 = p; + + printf("Done\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/a_1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,34 @@ +class Foo +{ + this(int j) + { + i = pi = j; + } + + int i; + +private: + + int pi; +} + +class Bar : Foo +{ + this(int j) + { + super(j); + baz = 42; + } + + int baz; +} + +void func() +{ + auto bar = new Bar(12); +} + +void main() +{ + func(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/aa1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module aa1; + +void main() +{ + int[int] aai; + assert(aai is null); + aai[0] = 52; + assert(aai !is null); + int i = aai[0]; + assert(i == 52); + aai[32] = 123; + int j = aai[32]; + assert(i == 52); + assert(j == 123); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/aa1_1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,21 @@ +module tangotests.aa1_1; + +extern(C) int printf(char*,...); + +void main() +{ + int[int] map; + map[1] = 1; + map[10] = 1; + map[11] = 11; + map[14] = 41; + map[21] = 12; + map[23] = 32; + map[32] = 23; + map[201] = 102; + foreach(k,v; map) + { + printf("%d:%d ", k,v); + } + printf("\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/aa2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module aa2; + +void main() +{ + long[float] aa; + long* p = 2.0f in aa; + assert(!p); + aa[4f] = 23; + p = 4f in aa; + assert(p); + assert(*p == 23); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/aa2_1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module tangotests.aa2_1; + +int main() +{ + int[cdouble] x; + cdouble d=22.0+0.0i; + x[d] = 44; + if(44 != x[d]){ + assert(0); + } + return 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/aa3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +module aa3; + +extern(C) int printf(char*, ...); +alias char[] string; + +void main() +{ + int[string] aa; + {aa["hello"] = 1;} + {int* p = "" in aa;} + aa[" worl"] = 2; + aa["d"] = 3; + aa["thisisgreat"] = 10; + int sum; + string cat; + { + foreach(k,v;aa) + { + printf("int[%.*s] = %d\n", k.length, k.ptr, v); + sum += v; + cat ~= k; + } + } + assert(sum == 16); + printf("cat = %.*s\n", cat.length, cat.ptr); + assert(cat.length == 22); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/aa4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,20 @@ +module aa4; + +void main() +{ + int[int] aa; + aa = addkey(aa,42,12); + int* p = haskey(aa,42); + assert(p && *p == 12); +} + +int[int] addkey(int[int] aa, int key, int val) +{ + aa[key] = val; + return aa; +} + +int* haskey(int[int] aa, int key) +{ + return key in aa; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/aa5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +module aa5; + +void main() +{ + int[int] aa; + aa[42] = 1; + int i = aa[42]; + assert(i == 1); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/aa6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +module aa6; + +extern(C) int printf(char*, ...); + +void main() +{ + int[int] aa; + aa = [1:1, 2:4, 3:9, 4:16]; + printf("---\n"); + foreach(int k, int v; aa) + printf("aa[%d] = %d\n", k, v); + aa.rehash; + printf("---\n"); + foreach(int k, int v; aa) + printf("aa[%d] = %d\n", k, v); + size_t n = aa.length; + assert(n == 4); + int[] keys = aa.keys; + assert(keys[] == [1,2,3,4][]); + int[] vals = aa.values; + assert(vals[] == [1,4,9,16][]); + aa.remove(3); + printf("---\n"); + foreach(int k, int v; aa) + printf("aa[%d] = %d\n", k, v); + assert(aa.length == 3); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/aa7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,20 @@ +// adapted from dstress.run.a.associative_array_19_<n> to catch regressions early + +module mini.aa7; + +extern (C) int printf(char*, ...); +extern (C) void gc_collect(); + + +int main(){ + char*[char] aa; + + char key = 'a'; + aa[key] = &key; + gc_collect(); + assert(aa[key] == &key); + assert(key in aa); + + return 0; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/aaequality.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,48 @@ +void test(K,V)(K k1, V v1, K k2, V v2, K k3, V v3) +{ + V[K] a, b; + a[k1] = v1; + a[k2] = v2; + assert(a != b); + assert(b != a); + assert(a == a); + assert(b == b); + + b[k1] = v1; + assert(a != b); + assert(b != a); + + b[k2] = v2; + assert(a == b); + assert(b == a); + + b[k1] = v2; + assert(a != b); + assert(b != a); + + b[k1] = v1; + b[k2] = v3; + assert(a != b); + assert(b != a); + + b[k2] = v2; + b[k3] = v3; + assert(a != b); + assert(b != a); +} + +void main() +{ + test!(int,int)(1, 2, 3, 4, 5, 6); + test!(char[],int)("abc", 2, "def", 4, "geh", 6); + test!(int,char[])(1, "abc", 2, "def", 3, "geh"); + test!(char[],char[])("123", "abc", "456", "def", "789", "geh"); + + Object a = new Object, b = new Object, c = new Object; + test!(Object, Object)(a, a, b, b, c, c); + + int[int] a2 = [1:2, 2:3, 3:4]; + int[int] b2 = [1:2, 2:5, 3:4]; + int[int] c2 = [1:2, 2:3]; + test!(int,int[int])(1,a2, 2,b2, 3,c2); +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/align1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +module tangotests.align1; + +extern(C) int printf(char*, ...); + +struct TLA +{ + char[3] tla; + char[] toString() { return tla; } + void dump() + { + printf("%.*s\n", 3, tla.ptr); + } +} + +void main() +{ + TLA fbi = TLA("FBI"); + fbi.dump(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/alignment.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,21 @@ +module alignment; + +align(1) struct S +{ + ubyte b; + int i; + ubyte[2] b2; + long l; + real r; +} + +void main() +{ + byte b; + short s; + int i; + long l; + float f; + double d; + real r; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/alloca1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,16 @@ +module alloca1; + +pragma(alloca) void* alloca(uint); + +extern(C) int printf(char*, ...); + +void main() +{ + int n = 16; + int* p = cast(int*)alloca(n*int.sizeof); + int[] a = p[0..n]; + a[] = 0; + foreach(i,v; a) { + printf("a[%2d] = %d\n", i, v); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/andand.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,3 @@ +bool ok = false; +void f(){ ok = true; } void main() { bool b=true; b && f(); assert(ok); } +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrayinit.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module arrayinit; +float[4] ftable = [1,2,3,4]; +int[8] itable = [3:42,6:123]; + +private uint[7] crc32_table = [0x00000000,0x77073096,0xee0e612c,0x990951ba,0x076dc419,0x706af48f,0xe963a535]; + +void main() +{ + assert(crc32_table[3] == 0x990951ba); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrayinit1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +void main() +{ + float m[4][4]; + + float* fp = &m[0][0]; + for (int i=0; i<16; i++,fp++) + assert(*fp !<>= 0); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrayinit2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +// bug #191 + +int[3] a = [0: 0, 2: 42, 1: 1]; + +void main() +{ + assert(a[0] == 0); + assert(a[1] == 1); // fails! + assert(a[2] == 42); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrayops1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +extern(C) int printf(char*, ...); + +void main() +{ + int[3] a = [1, 2, 3]; + int[3] b = [4, 5, 6]; + int[3] c; + + c[] = a[] + b[]; + + printf("c.ptr = %p\n", c.ptr); + printf("c.length = %lu\n", c.length); + + assert(c[0] == 5); + assert(c[1] == 7); + assert(c[2] == 9); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrayops2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +void main() +{ + int[4] a = [1,2,3,4]; + int[4] b = [5,6,7,8]; + a[] += b[]; + assert(a[0] == 6); + assert(a[1] == 8); + assert(a[2] == 10); + assert(a[3] == 12); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrayops3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +void main() +{ + int[4] a = [1,2,3,4]; + int[4] b = [5,6,7,8]; + a[] += b[] / 2; + assert(a[0] == 3); + assert(a[1] == 5); + assert(a[2] == 6); + assert(a[3] == 8); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrayops4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,29 @@ +void main() +{ + auto a = new float[1024]; + auto b = new float[1024]; + auto c = new float[1024]; + + for (auto i=0; i<1024; i++) + { + a[i] = i; + b[i] = i*2; + c[i] = i*4; + } + + a[] = b[] + c[] / 2; + + foreach(i,v; a) + { + assert(eq(v, b[i] + c[i] / 2)); + } +} + +float abs(float x) +{ + return x<0?-x:x; +} +bool eq(float a, float b) +{ + return abs(a-b) <= float.epsilon; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,43 @@ +module arrays1; + +extern(C) int printf(char*, ...); + +void integer() +{ + auto arr = new int[16]; + arr[1] = 42; + arr[6] = 555; + print_int(arr); + delete arr; +} + +void floating() +{ + auto arr = new float[6]; + arr[1] = 3.14159265; + arr[3] = 1.61803399; + print_float(arr); + delete arr; +} + +void print_int(int[] arr) +{ + printf("arr[%lu] = [", arr.length); + for (auto i=0; i<arr.length; i++) + printf("%d,", arr[i]); + printf("\b]\n"); +} + +void print_float(float[] arr) +{ + printf("arr[%lu] = [", arr.length); + for (auto i=0; i<arr.length; i++) + printf("%f,", arr[i]); + printf("\b]\n"); +} + +void main() +{ + integer(); + floating(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays10.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +module arrays10; + +void main() +{ + int[] a = new int[10]; + a[] = 3; +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays11.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,51 @@ +module arrays11; + +void ints() +{ + int[] a = [1,2,3,4,5,6]; + {assert(a == a);} + + int[] b = [4,5,6,7,8,9]; + {assert(a != b);} + {assert(a[3..$] == b[0..3]);} +} + +void floats() +{ + float[] a = [1.0f, 2.0f, 3.0f, 4.0f]; + {assert(a == a);} + + float[] b = [2.0f, 3.0f, 5.0f]; + {assert(a != b);} + {assert(a[1..3] == b[0..2]);} +} + +struct S +{ + int i; + int j; + + int opEquals(S s) + { + return (i == s.i) && (j == s.j); + } +} + +void structs() +{ + S[] a = [S(0,0), S(1,0), S(2,0), S(3,0)]; + {assert(a == a);} + S[] b = [S(0,1), S(1,0), S(2,0), S(3,1)]; + {assert(a != b);} + {assert(a[1..3] == b[1..3]);} + + S[2] c = [S(2,0), S(3,1)]; + {assert(c == b[2..$]);} +} + +void main() +{ + ints(); + floats(); + structs(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays12.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +module arrays12; + +void ints() +{ + int[3] a = [1,2,3]; + int[3] b = [2,3,4]; + int[3] c = [2,5,0]; + {assert(a < b);} + {assert(b > a);} + {assert(a < c);} + {assert(c > a);} + {assert(b < c);} + {assert(c > b);} +} + +void main() +{ + ints(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays13.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module arrays13; + +extern(C) int printf(char*, ...); + +void main() +{ + char[] 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"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays14.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +module arrays14; + +void main() +{ + auto s = "hello world"; + auto d = s.dup; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays16.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,30 @@ +module mini.arrays16; + +void main() +{ + intarrays!(byte)(); + intarrays!(ubyte)(); + intarrays!(short)(); + intarrays!(ushort)(); + intarrays!(int)(); + intarrays!(uint)(); + intarrays!(long)(); + intarrays!(ulong)(); +} + +void intarrays(T)() +{ + T[] ia = [cast(T)1,2,3,4]; + T[] ib = [cast(T)1,2,3,4]; + T[] ic = [cast(T)1,2,3]; + T[] id = [cast(T)1,2,3,4,5]; + + assert(ia == ia); + assert(ia == ib); + assert(ia != ic); + assert(ia != id); + assert(ia > ic); + assert(ia !< ic); + assert(ia < id); + assert(ia !> id); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays17.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,6 @@ +module mini.arrays17; + +void main() +{ + const char[2][2] id = [1: "ab"]; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays18.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +module mini.arrays18; + +struct Str { int a,b; } +void main() { + Str[] arr = new Str[64]; + + auto tmp = Str(1,2); + arr[] = tmp; + assert(arr[0].a == 1); + assert(arr[0].b == 2); + assert(arr[13].a == 1); + assert(arr[13].b == 2); + assert(arr[42].a == 1); + assert(arr[42].b == 2); + assert(arr[63].a == 1); + assert(arr[63].b == 2); + + arr[] = Str(3,4); + assert(arr[0].a == 3); + assert(arr[0].b == 4); + assert(arr[13].a == 3); + assert(arr[13].b == 4); + assert(arr[42].a == 3); + assert(arr[42].b == 4); + assert(arr[63].a == 3); + assert(arr[63].b == 4); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays19.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +module mini.arrays19; + +extern(C) int printf(char*, ...); + +void main() +{ + bool var = ([] is null); + assert(var); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +char[] get() +{ + return "hello"; +} + +void param(char[] s) +{ +} + +void refparam(ref char[] s) +{ +} + +void main() +{ + char[] dstr = get(); + param(dstr); + refparam(dstr); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays20.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,23 @@ +module mini.arrays20; + +int[] foo() +{ + return [2,4,6]; +} + +int[] bar() +{ + return [1,3,5]; +} + +void main() +{ + auto a = foo(); + auto b = bar(); + assert(b[0] == 1); + assert(a[0] == 2); + assert(b[1] == 3); + assert(a[1] == 4); + assert(b[2] == 5); + assert(a[2] == 6); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module arrays3; + +void main() +{ + int[] arr; + {arr = new int[25];} + {assert(arr.length == 25);} + {arr.length = arr.length + 5;} + {assert(arr.length == 30);} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module arrays4; + +void main() +{ + int[] arr; + arr ~= 3; + assert(arr.length == 1); + assert(arr[0] == 3); + arr ~= 5; + assert(arr.length == 2); + assert(arr[0] == 3); + assert(arr[1] == 5); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module arrays5; +void main() +{ + auto arr = new float[5]; + {arr[4] = 1f;} + {assert(arr[0] !<>= 0f);} + {assert(arr[1] !<>= 0f);} + {assert(arr[2] !<>= 0f);} + {assert(arr[3] !<>= 0f);} + {assert(arr[4] == 1f);} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,6 @@ +module arrays6; + +void main() +{ + int[4] a = [1,2,3,4]; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,31 @@ +module arrays7; + +extern(C) int printf(char*, ...); + +struct S +{ + int i; + float f; + long l; + + void print() + { + printf("%d %f %lx\n", i, f, l); + } +} + +void main() +{ + S[] arr; + S s; + assert(arr.length == 0); + arr ~= s; + assert(arr.length == 1); + arr ~= S(1,2.64,0xFFFF_FFFF_FFFF); + assert(arr.length == 2); + arr[0].print(); + arr[1].print(); + assert(arr[1].i == 1); + assert(arr[1].f > 2.63 && arr[1].f < 2.65); + assert(arr[1].l == 0xFFFF_FFFF_FFFF); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays8.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +module arrays8; + +extern(C) int printf(char*, ...); + +void main() +{ + char[] a = "hello "; + printf(" \"%s\".length = %u\n", a.ptr, a.length); + char[] b = "world"; + printf(" \"%s\".length = %u\n", b.ptr, b.length); + char[] c = a ~ b; + printf("After 'a ~ b':\n"); + printf(" \"%.*s\".length = %u\n", a.length, a.ptr, a.length); + printf(" \"%.*s\".length = %u\n", b.length, b.ptr, b.length); + printf(" \"%.*s\".length = %u\n", c.length, c.ptr, c.length); + assert(c.length == a.length + b.length); + assert(c !is a); + assert(c !is b); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/arrays9.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module arrays9; + +const int[] g = [1,2,3,4]; + +void main() +{ + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/asm1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,31 @@ +module asm1; + +extern(C) int printf(char*, ...); + +void main() +{ + version(D_InlineAsm_X86) + { + int x; + asm + { + mov EAX, 42; + mov x, EAX; + } + printf("x = %d\n", x); + } + else version(D_InlineAsm_X86_64) + { + long x; + asm + { + movq RAX, 42L; + movq x, RAX; + } + printf("x = %ld\n", x); + } + else + { + static assert(0, "no inline asm for this platform yet"); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/asm10.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,31 @@ +module asm10; + +struct S { + ushort first; + ushort second; + int unaccessed; +} + +void main() { + auto s = S(512, 42, -1); + ushort x = 0; + version(D_InlineAsm_X86) { + asm { + lea EAX, s; + mov CX, S.second[EAX]; + mov x, CX; + mov S.first[EAX], 640; + } + } else version(D_InlineAsm_X86_64) { + asm { + lea RAX, s; + mov CX, S.second[RAX]; + mov x, CX; + mov S.first[RAX], 640; + } + } + assert(x == 42); + assert(s.first == 640); + assert(s.second == 42); + assert(s.unaccessed == -1); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/asm1_1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,35 @@ +module tangotests.asm1_1; + +extern(C) int printf(char*, ...); + +int main() +{ + int i = 12; + int* ip = &i; + printf("%d\n", i); + version (D_InlineAsm_X86) + { + asm + { + mov ECX, ip; + mov EAX, [ECX]; + add EAX, 8; + mul EAX, EAX; + mov [ECX], EAX; + } + } + else version (D_InlineAsm_X86_64) + { + asm + { + movq RCX, ip; + mov EAX, [RCX]; + add EAX, 8; + imul EAX, EAX; + mov [RCX], EAX; + } + } + printf("%d\n", i); + assert(i == 400); + return 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/asm2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,32 @@ +module tangotests.asm2; + +extern(C) int printf(char*, ...); + +int main() +{ + int i = 40; + int j = 2; + version(D_InlineAsm_X86) + { + asm + { + mov EAX, i; + mov EBX, j; + add EAX, EBX; + mov i, EAX; + } + } + else version(D_InlineAsm_X86_64) + { + asm + { + mov EAX, i; + mov EBX, j; + add EAX, EBX; + mov i, EAX; + } + } + printf("42 = %d\n", i); + assert(i == 42); + return 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/asm3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +module tangotests.asm3; + +extern(C) int printf(char*, ...); + +void main() +{ + char* fmt = "Hello D World\n"; + printf(fmt); + version (D_InlineAsm_X86) + { + asm + { + push fmt; + call printf; + pop EAX; + } + } + else version(D_InlineAsm_X86_64) + { + asm + { + movq RDI, fmt; + xor AL, AL; + call printf; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/asm4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,41 @@ +module tangotests.asm4; + +extern(C) int printf(char*,...); + +void main() +{ + char* stmt = "yay!\n"; + char* fmt = "%s"; + version (D_InlineAsm_X86) + { + asm + { + jmp L2; + L1:; + jmp L3; + L2:; + jmp L1; + L3:; + push stmt; + call printf; + pop EAX; + } + } + else version(D_InlineAsm_X86_64) + { + asm + { + jmp L2; + L1:; + jmp L3; + L2:; + jmp L1; + L3:; + movq RDI, fmt; + movq RSI, stmt; + xor AL, AL; + call printf; + } + } + printf(fmt,stmt); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/asm5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,33 @@ +int foo() +{ + version(X86) + { + asm { mov EAX, 42; } + } else version(X86_64) + { + asm { movq RAX, 42; } + } + else static assert(0, "todo"); +} + +ulong bar() +{ + version(X86) + { + asm { mov EAX, 0xFF; mov EDX, 0xAA; } + } else version(X86_64) + { + asm { movq RAX, 0xAA000000FF; } + } + else static assert(0, "todo"); +} + +void main() +{ + long l = 1; + l = 2; + l = 4; + l = 8; + assert(foo() == 42); + assert(bar() == 0xAA000000FF); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/asm6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,33 @@ +extern(C) int printf(char*, ...); + +version (D_InlineAsm_X86) + version = InlineAsm_X86_Any; +version (D_InlineAsm_X86_64) + version = InlineAsm_X86_Any; + +void main() +{ + int a,b,c; + a = int.max-1; + b = 5; + version (InlineAsm_X86_Any) + { + asm + { + mov EAX, a; + mov ECX, b; + add EAX, ECX; + jo Loverflow; + mov c, EAX; + } + } + printf("a == %d\n", a); + printf("b == %d\n", b); + printf("c == %d\n", c); + assert(c == c); + return; + +Loverflow: +int y=0; + //assert(0, "overflow"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/asm7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,71 @@ +module tangotests.asm7; + +// test massive label collisions (runtime uses Loverflow too) +extern(C) int printf(char*, ...); + +void main() +{ + int a = add(1,2); + int s = sub(1,2); + assert(a == 3); + assert(s == -1); +} + +int add(int a, int b) +{ + int res; + version (D_InlineAsm_X86) + { + asm + { + mov EAX, a; + add EAX, b; + jo Loverflow; + mov res, EAX; + } + } + else version (D_InlineAsm_X86_64) + { + asm + { + mov EAX, a; + add EAX, b; + jo Loverflow; + mov res, EAX; + } + } + printf("%d\n",res); + return res; +Loverflow: + assert(0, "add overflow"); +} + +int sub(int a, int b) +{ + int res; + version (D_InlineAsm_X86) + { + asm + { + mov EAX, a; + sub EAX, b; + jo Loverflow; + mov res, EAX; + } + } + else version (D_InlineAsm_X86_64) + { + asm + { + mov EAX, a; + sub EAX, b; + jo Loverflow; + mov res, EAX; + } + } + printf("%d\n",res); + return res; +Loverflow: + assert(0, "sub overflow"); + int x; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/asm8.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,401 @@ +const float one_f = 1; +const double one_d = 1; +const real one_r = 1; + +int foo() +{ + version(X86) + { + asm { mov EAX, 42; } + } + else version (X86_64) + { + asm { mov EAX, 42; } + } + else static assert(0, "todo"); +} + +ulong bar() +{ + version(X86) + { + asm { mov EDX, 0xAA; mov EAX, 0xFF; } + } + else version (X86_64) + { + asm { movq RAX, 0xAA000000FF; } + } + else static assert(0, "todo"); +} + + +float onef() +{ + version(X86) + { + asm { fld1; } + } + else version (X86_64) + { + asm { movss XMM0, [one_f]; } + } + else static assert(0, "todo"); +} + +double oned() +{ + version(X86) + { + asm { fld1; } + } + else version (X86_64) + { + asm { movsd XMM0, [one_d]; } + } + else static assert(0, "todo"); +} + +real oner() +{ + version(X86) + { + asm { fld1; } + } + else version (X86_64) + { + asm { fld1; } + } + else static assert(0, "todo"); +} + +ifloat oneif() +{ + version(X86) + { + asm { fld1; } + } + else version (X86_64) + { + asm { movss XMM0, [one_f]; } + } + else static assert(0, "todo"); +} + +idouble oneid() +{ + version(X86) + { + asm { fld1; } + } + else version (X86_64) + { + asm { movsd XMM0, [one_d]; } + } + else static assert(0, "todo"); +} + +ireal oneir() +{ + version(X86) + { + asm { fld1; } + } + else version (X86_64) + { + asm { fld1; } + } + else static assert(0, "todo"); +} + + +const float two_f = 2; + +cfloat cf() +{ + version(X86) + { + asm { fld1; fld two_f; } + } + else version (X86_64) + { + asm + { + movss XMM0, [one_f]; + movss XMM1, [two_f]; + } + } + else static assert(0, "todo"); +} + +extern(C) cfloat cf_C() +{ + version(X86) + { + asm { + mov EAX, [one_f]; + mov EDX, [two_f]; + } + } + else version (X86_64) + { + asm { + mov EAX, [one_f]; + mov ECX, [two_f]; + + shl RCX, 32; + or RAX, RCX; + + movd XMM0, RAX; + } + } + else static assert(0, "todo"); +} + +cfloat cf2() +{ + version(X86) + { + asm + { + naked; + fld1; + fld two_f; + ret; + } + } + else version (X86_64) + { + asm + { + naked; + movss XMM0, [one_f]; + movss XMM1, [two_f]; + ret; + } + } + else static assert(0, "todo"); +} + +extern(C) cfloat cf2_C() +{ + version(X86) + { + asm + { + naked; + mov EAX, [one_f]; + mov EDX, [two_f]; + ret; + } + } + else version (X86_64) + { + asm { + naked; + mov EAX, [one_f]; + mov ECX, [two_f]; + + shl RCX, 32; + or RAX, RCX; + + movd XMM0, RAX; + ret; + } + } + else static assert(0, "todo"); +} + + +const double two_d = 2; + +cdouble cd() +{ + version(X86) + { + asm { fld1; fld two_d; } + } + else version (X86_64) + { + asm + { + leaq RAX, [one_d]; + leaq RCX, [two_d]; + movsd XMM0, [RAX]; + movsd XMM1, [RCX]; + } + } + else static assert(0, "todo"); +} + +cdouble cd2() +{ + version(X86) + { + asm + { + naked; + fld1; + fld two_d; + ret; + } + } + else version (X86_64) + { + asm + { + naked; + movsd XMM0, [one_d]; + movsd XMM1, [two_d]; + } + } + else static assert(0, "todo"); +} + + +const real two_r = 2.0; + +creal cr() +{ + version(X86) + { + asm { fld1; fld two_r; } + } + else version (X86_64) + { + asm { fld two_r; fld1; } + } + else static assert(0, "todo"); +} + +creal cr2() +{ + version(X86) + { + asm + { + naked; + fld1; + fld two_r; + ret; + } + } + else version (X86_64) + { + asm + { + naked; + fld two_r; + fld1; + ret; + } + } + else static assert(0, "todo"); +} + +void* vp() +{ + version(X86) + { + asm { mov EAX, 0x80; } + } + else version (X86_64) + { + asm { movq RAX, 0x80; } + } + else static assert(0, "todo"); +} + +int[int] gaa; + +int[int] aa() +{ + version(X86) + { + asm { mov EAX, gaa; } + } + else version (X86_64) + { + asm { movq RAX, gaa; } + } + else static assert(0, "todo"); +} + +Object gobj; + +Object ob() +{ + version(X86) + { + asm { mov EAX, gobj; } + } + else version (X86_64) + { + asm { movq RAX, gobj; } + } + else static assert(0, "todo"); +} + +char[] ghello = "hello world"; + +char[] str() +{ + version(X86) + { + asm { lea ECX, ghello; mov EAX, [ECX]; mov EDX, [ECX+4]; } + } + else version (X86_64) + { + asm { movq RAX, [ghello]; movq RDX, [ghello]+8; } + } + else static assert(0, "todo"); +} + +char[] delegate() dg() +{ + version(X86) + { + asm { mov EAX, gobj; lea EDX, Object.toString; } + } + else version (X86_64) + { + asm { movq RAX, [gobj]; leaq RDX, Object.toString; } + } + else static assert(0, "todo"); +} + +void main() +{ + gaa[4] = 5; + gobj = new Object; + auto adg = &gobj.toString; + + assert(foo() == 42); + assert(bar() == 0xAA000000FF); + assert(onef() == 1); + assert(oned() == 1); + assert(oner() == 1); + + assert(oneif() == 1i); + assert(oneid() == 1i); + assert(oneir() == 1i); + + assert(cf() == 1+2i); + assert(cf2() == 1+2i); + + assert(cf_C() == 1+2i); + assert(cf2_C() == 1+2i); + + assert(cd() == 1+2i); + assert(cd2() == 1+2i); + + assert(cr() == 1+2i); + assert(cr2() == 1+2i); + + assert(vp() == cast(void*)0x80); + assert(aa() is gaa); + assert(ob() is gobj); + assert(str() == "hello world"); + assert(dg()() == "object.Object"); +} + +extern(C) int printf(char*, ...);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/asm9.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,28 @@ +module asm9; + +version(X86) version = DoSome; +else version(X86_64) version = DoSome; + +T add(T, T t)(T a) { + asm { + add a, t; + } + return a; +} + +void main() { + version (DoSome) { + assert(add!(ubyte, 20)(10) == 30); + assert(add!(ushort, 20_000)(10_000) == 30_000); + assert(add!(uint, 2_000_000)(1_000_000) == 3_000_000); + } + version(X86_64) { + // 64-bit immediates aren't allowed on "ADD", nor are + // unsigned 32-bit ones, so make the template parameter + // fit in a 32-bit signed int. + // These values were chosen so that the lower 32-bits overflow + // and we can see the upper half of the 64-bit input increment. + auto result = add!(long, 2_000_000_000)(21_000_000_000); + assert(result == 23_000_000_000); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/assign.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,23 @@ +module assign; + +// this is taken from std.intrinsic from gdc + +int mybtc(uint *p, uint bitnum) +{ + uint * q = p + (bitnum / (uint.sizeof*8)); + uint mask = 1 << (bitnum & ((uint.sizeof*8) - 1)); + int result = *q & mask; + *q ^= mask; + return result ? -1 : 0; +} + +void main() +{ + uint i = 0xFFFF_FFFF; + int r = mybtc(&i, 31); + assert(r); + assert(i == 0x7FFF_FFFF); + r = mybtc(&i, 31); + assert(!r); + assert(i == 0xFFFF_FFFF); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/assign1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module mini.assign1; + +extern(C) int printf(char*, ...); + +struct X +{ + int a; + alias a b; +} +void main() +{ + X e = void; + e.a = e.b = 5; + printf("%d - %d\n", e.a, e.b); + assert(e.a == 5); + assert(e.a == e.b); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/atomic1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module mini.atomic1; + +pragma(intrinsic, "llvm.atomic.swap.i#.p0i#") + T atomic_swap(T)(T* ptr, T val); + +void main() +{ + int i = 42; + int j = atomic_swap(&i, 43); + assert(j == 42); + assert(i == 43); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/b.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,25 @@ +module b; + +extern(C) int printf(char*, ...); + +struct S +{ + int i; + float[4] f; +} + +void main() +{ + S s; + int i = s.i; + int* p = &s.i; + *p = 42; + printf("%d == %d\n", *p, s.i); + + float* f = &s.f[0]; + printf("%f == %f\n", *f, s.f[0]); + *f = 3.1415; + printf("%f == %f\n", *f, s.f[0]); + s.f[0] = 123.456; + printf("%f == %f\n", *f, s.f[0]); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bitops.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,78 @@ + +extern(C) int printf(char*, ...); + +void main() +{ + printf("Bitwise operations test\n"); + { ushort a = 0xFFF0; + ushort b = 0x0FFF; + assert((a&b) == 0x0FF0); + assert((a|b) == 0xFFFF); + assert((a^b) == 0xF00F); + } + { ubyte a = 0xFF; + ulong b = 0xFFFF_FFFF_FFFF_FFF0; + assert((a&b) == 0xF0); + } + { ushort s = 0xFF; + assert((s<<1) == s*2); + assert((s>>>1) == s/2); + } + { int s = -10; + assert((s>>1) == -5); + assert((s>>>1) != -5); + } + + { ushort a = 0xFFF0; + ushort b = 0x0FFF; + auto t = a; + t &= b; + assert(t == 0x0FF0); + t = a; + t |= b; + assert(t == 0xFFFF); + t = a; + t ^= b; + assert(t == 0xF00F); + } + { ubyte a = 0xFF; + ulong b = 0xFFFF_FFFF_FFFF_FFF0; + a &= b; + assert(a == 0xF0); + } + { ushort s = 0xFF; + auto t = s; + t <<= 1; + assert(t == (s*2)); + t = s; + t >>>= 1; + assert(t == s/2); + } + { int s = -10; + auto t = s; + t >>= 1; + assert(t == -5); + t = s; + t >>>= 1; + assert(t != -5); + } + { struct S + { + uint i; + ulong l; + }; + S s = S(1,4); + auto a = s.i | s.l; + assert(a == 5); + s.i = 0xFFFF_00FF; + s.l = 0xFFFF_FFFF_0000_FF00; + s.l ^= s.i; + assert(s.l == ulong.max); + s.i = 0x__FFFF_FF00; + s.l = 0xFF00FF_FF00; + s.i &= s.l; + assert(s.i == 0x00FF_FF00); + } + + printf(" SUCCESS\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/boolexp.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +bool got() { return true; } +extern(C) int printf(char*, ...); +void main() +{ + bool b = true && got(); + printf("%d\n", b ? 1 : 0); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,5 @@ +module bug1; +struct Foo { Foo opSub(ref Foo b) { return Foo(); } } +struct Bar { Foo whee; } +void test(ref Bar moo) { Foo nngh; auto plonk = nngh - moo.whee; } +void main() { Bar bar; test(bar); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug10.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,24 @@ +module bug10; +extern(C) int printf(char*, ...); + +class C +{ + char[] msg; + + this() + { + } + this(char[] msg) + { + this.msg = msg; + } +} + +void main() +{ + auto c = new C(); + c.msg = "world"; + auto b = new C("hello"); + printf("%.*s\n", b.msg.length, b.msg.ptr); + printf("%.*s\n", c.msg.length, c.msg.ptr); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug11.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module bug11; + +struct S +{ + int[4] arr; +} + +S s=S([1,2,3,4]); + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug12.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,6 @@ +module bug12; + +void main() +{ + const char[] name="y"; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug13.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module bug13; + +void func1(ubyte[4]* arr) +{ + ubyte* b = &(*arr)[0]; + func2(&(*arr)[1]); +} + +void func2(ubyte* ptr) +{ + assert(*ptr == 2); +} + +void main() +{ + ubyte[4] arr = [cast(ubyte)1,2,3,4]; + func1(&arr); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug14.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +module bug14; + +void main() +{ + int[] arr = new int[12]; + int i = arr[0]; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug15.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module bug15; + +bool bool1(bool b) { + if (b) return true; + else return false; +} + +bool bool2(bool b) { + if (b) {return true;} + else {return false;} +} + +void main() +{ + assert(bool1(true)); + assert(!bool2(false)); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug16.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module bug16; + +void func(long val) +{ + val >>= 32; +} + +void main() +{ + func(64L); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug163_void_condexp.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ + +static foocalled = false; +static barcalled = false; +void foo() { foocalled = true; } +void bar() { barcalled = true; } + +void f(bool b) +{ + return b ? foo() : bar(); +} + +void main() +{ + f(true); + assert(foocalled && !barcalled); + f(false); + assert(foocalled && barcalled); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug17.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module bug17; + +struct Vec +{ + Vec opAdd(ref Vec b) { return Vec(); } + Vec opMul(double a) { return Vec(); } +} +void main() +{ + Vec foo; + Vec bar; + auto whee=foo+bar*1f; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug18.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module bug18; + +struct S { + int[9] i; +} + +void main() +{ + int[9] i; + auto s = S(i); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug189_interfacecast.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +interface I {} +class A : I {} +class B : A {} + +void main () { + A a = new A; + I i = a; + + assert(!cast(B)a); + assert(!cast(B)i); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug19.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +module bug19; + +void main() +{ + auto dg = (int i) { return i*2; }; + assert(dg(2) == 4); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug198_ctfestructinit.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +struct Color { + uint c; + static Color opCall(uint _c) { Color ret; ret.c = _c; return ret; } +} + +// run at compile time +static const Color white = Color(0xffffffff); + +void main() +{ + assert(white.c == 0xffffffff); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug199_ctfestructinit.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,25 @@ +struct Color { + uint c; + +} + +struct Vertex { + double x, y; + Color c; + static Vertex opCall(double x, double y, Color c) { + Vertex ret; + ret.x = x; + ret.y = y; + ret.c = c; + return ret; + } +} + +void main() { + Color c = {0xffffffff}; + + auto v = Vertex(1, 5, c); + + assert(v.x == 1 && v.y == 5); // passes + assert(v.c.c == 0xffffffff); // fails in LDC +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,4 @@ +module bug2; +struct Vec { Vec barf() { return Vec(); } } +class test { this(Vec whee) { } } +void main() { Vec whee; new test(whee.barf()); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug20.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +module bug20; +extern(C) int printf(char*, ...); + +void func(void delegate() dg) +{ + dg(); +} + +void main() +{ + int i = 42; + void delegate() dg = { + i++; + }; + printf("i = %d\n",i); + func(dg); + printf("i = %d\n",i); + assert(i == 43); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug21.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module bug21; +extern(C) int printf(char*, ...); + +void main() +{ + int i = 42; + auto a = { + int j = i*2; + auto b = { + return j; + }; + return b(); + }; + int i2 = a(); + printf("%d\n", i2); + assert(i2 == i*2); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug22.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module bug22; +extern(C) int printf(char*, ...); + +void main() +{ + int i; + delegate { + i = 42; + }(); + printf("%d\n", i); + assert(i == 42); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug23.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module bug23; +extern(C) int printf(char*, ...); + +void main() +{ + int i; + delegate { + i++; + delegate { + i++; + }(); + }(); + printf("%d\n", i); + assert(i == 2); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug24.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,22 @@ +module bug24; +extern(C) int printf(char*, ...); + +struct S +{ + long l; + float f; +} + +void main() +{ + S s = S(3L,2f); + delegate { + S t = S(4L, 1f); + delegate { + s.l += t.l; + s.f += t.f; + }(); + }(); + printf("%lu %f\n", s.l, s.f); + assert(s.l == 7 && s.f == 3); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug25.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module bug25; +extern(C) int printf(char*, ...); + +void main() +{ + int i = 2; + delegate { + i = i*i; + i += i*i; + }(); + printf("%d\n", i); + assert(i == 20); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug27.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module bug27; + +int func(int a, int b) +{ + if (a == b) + return 0; + else if (a < b) + return -1; + else + return 1; +} + +void main() +{ + int i = func(3,4); + assert(i == -1); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug28.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module bug28; + +void main() +{ + char[] a = "hello"; + char[] b = "hello"; + char[] c = "world"; + char[] d = "somethingelse"; + assert(a == a); + assert(a == b); + assert(a != c); + assert(b != c); + assert(a != d); + assert(b != d); + assert(c != d); + assert(d == d); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug29.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,16 @@ +module bug29; +extern(C) int printf(char*, ...); + +void main() +{ + int[] arr16 = new int[4]; + { + void[] arr = arr16; + { + printf("%lu\n", arr.length); + { + assert(arr.length == 16); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,24 @@ +module bug3; + +struct S +{ + int[] arr; + char[5] ch; +} + +class C +{ + int[] arr; + char[4] crs; +} + +void main() +{ + S s; + s.arr = new int[5]; + s.arr[1] = 32; + int i; + i = s.arr[0]; + //assert(s.arr[0] == 0); + //assert(s.arr[1] == 32); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug30.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,22 @@ +module bug30; + +void main() +{ + int[] a = new int[4]; + {a[0] = 1; + a[1] = 2; + a[2] = 3; + a[3] = 4;} + int[] b = new int[4]; + {b[0] = 1; + b[1] = 2; + b[2] = 3; + b[3] = 4;} + int[] c = new int[4]; + {c[0] = 1; + c[1] = 2; + c[2] = 4; + c[3] = 3;} + {assert(a == b);} + {assert(a != c);} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug308_double_finally.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,20 @@ +extern(C) int printf(char*, ...); + +long foo(ref int p) { + try { return 0; } + finally { + p++; + throw new Object; + } +} + +void main() { + int p = 0; + try { + foo(p); + assert(0); + } catch { + } + printf("Number of types scope(exit) was executed : %d\n", p); + assert(p == 1); +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug32.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module bug32; +extern(C) int printf(char*, ...); + +struct S +{ + char[] getName() { return name; } + char[] name; +} + +void main() +{ + S s = S("Kyle"); + char[] name = s.name; + printf("%.*s\n", name.length, name.ptr); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug33.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,33 @@ +module bug33; + +extern(C) int memcmp(void*,void*,size_t); + +private int string_cmp(char[] s1, char[] s2) +{ + auto len = s1.length; + if (s2.length < len) + len = s2.length; + int result = memcmp(s1.ptr, s2.ptr, len); + if (result == 0) + result = cast(int)(cast(ptrdiff_t)s1.length - cast(ptrdiff_t)s2.length); + return result; +} + +struct S +{ + char[] toString() + { + return "S"; + } +} + +int func() +{ + S a,b; + return string_cmp(a.toString(),b.toString()); +} + +void main() +{ + assert(func() == 0); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug34.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,55 @@ +module bug34; + +class MyTypeInfo_Pointer +{ + char[] toString() { return m_next.toString() ~ "*"; } + + int opEquals(Object o) + { TypeInfo_Pointer c; + + return this is o || + ((c = cast(TypeInfo_Pointer)o) !is null && + this.m_next == c.m_next); + } + + hash_t getHash(void *p) + { + return cast(uint)*cast(void* *)p; + } + + int equals(void *p1, void *p2) + { + return cast(int)(*cast(void* *)p1 == *cast(void* *)p2); + } + + int compare(void *p1, void *p2) + { + if (*cast(void* *)p1 < *cast(void* *)p2) + return -1; + else if (*cast(void* *)p1 > *cast(void* *)p2) + return 1; + else + return 0; + } + + size_t tsize() + { + return (void*).sizeof; + } + + void swap(void *p1, void *p2) + { void* tmp; + tmp = *cast(void**)p1; + *cast(void**)p1 = *cast(void**)p2; + *cast(void**)p2 = tmp; + } + + TypeInfo next() { return m_next; } + uint flags() { return 1; } + + TypeInfo m_next; +} + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug35.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +module bug35; + +private const char[10] digits = "0123456789"; /// 0..9 + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug36.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module bug36; + +void main() +{ + int[] a; + void* cp = cast(void*)a; + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug37.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +module bug37; + +void main() +{ + char[] a = "hello"; + assert(a !is null); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug372.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +class A { + class B { + } +} + +class C : A { + void test () { + B foo = new B(); + } +} + +int main () { + return 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug38.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module bug38; + +void func(int* p) +{ + p++; +} + +void main() +{ + int i; + func(&i); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug39.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module bug39; + +struct S +{ + long l; +} + +void main() +{ + S s; + s.l = 23; + void* p = &s; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module bug4; + +int func(int i) +{ + i += 2; + i -= 3; + return i; +} + +void main() +{ + assert(func(4) == 3); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug40.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module bug40; + +char[] func(void* p) +{ + return null; +} + +void main() +{ + char[] function(void*) fp = &func; + assert(fp(null) is null); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug41.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module bug41; + +void main() +{ + char[] a = "hello world"; + char* ap = a.ptr; + size_t i = 5; + char[] b = ap[0..i]; + assert(b == "hello"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug42.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module bug42; + +void main() { + int i = 2; + switch (i) { + case 0: + case 1: + default: + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug43.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,16 @@ +module bug43; + +struct S +{ + ubyte[3] vals; +} + +void func(ubyte[3] v) +{ +} + +void main() +{ + S s; + func(s.vals); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug44.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,20 @@ +module bug44; + +struct rgb +{ + long l; +} + +void foo() +{ +} + +rgb test() { + scope(exit) foo(); + return rgb(); +} + +void main() +{ + rgb r = test(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug45.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module bug45; + +void foo() { + int bar; + scope(exit) { bar++; } + if (bar) return; +} + +void main() { + foo(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug47.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module bug47; + +bool func(bool a, bool b) +{ + if (a) b = false; + return b; +} + +void main() +{ + assert(func(0,0) == 0); + assert(func(0,1) == 1); + assert(func(1,0) == 0); + assert(func(1,1) == 0); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug48.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module bug48; + +size_t func(void *p) +{ + return cast(size_t)*cast(void* *)p; +} + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug49.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module bug49; + +struct S +{ + int i; + long l; +} + +void main() +{ + S s; + s.i = 0x__FFFF_FF00; + s.l = 0xFF00FF_FF00; + s.i &= s.l; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module bug5; + +struct hah { + static hah f() + { + hah res; + return res; + } + hah g() + { + return hah.init; + } +} + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug50.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,28 @@ +module bug50; +extern(C) int printf(char*, ...); + +struct S +{ + int i; + float f; + long l; + + void print() + { + printf("%d %f %lx\n", i, f, l); + } +} + +void main() +{ + S s; + s.print(); + s = S(1,2,3); + s.print(); + + S[] arr; + {arr ~= s;} + {arr[0].print();} + {arr ~= S(1,2,3);} + {arr[1].print();} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug51.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module bug51; +const ubyte[3] arr1 = 1; +const ubyte[3] arr2 = [1]; +const ubyte[3] arr3 = [1:1]; +void main() +{ + assert(arr1 == [cast(ubyte)1,1,1][]); + assert(arr2 == [cast(ubyte)1,0,0][]); + assert(arr3 == [cast(ubyte)0,1,0][]); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug52.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,5 @@ +module bug52; +struct Vec { double x,y,z; } +struct Pair(T, U) { T first; U second; } +typedef Pair!(double, Vec) Hit; +void main() {}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug53.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,6 @@ +module bug53; +class Foo { + final void bar() {} + void test() { bar(); } +} +void main() {}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug54.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module bug54; + +extern(C) size_t strlen(char*); + +// creating args for main +void d_main_args(size_t n, char** args, ref char[][] res) +{ + assert(res.length == n); + foreach(i,v; args[0..n]) + { + res[i] = v[0 .. strlen(v)]; + } +} + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug55.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,21 @@ +module bug55; +extern(C) int printf(char*, ...); + +int atoi(char[] s) { + int i, fac=1; + bool neg = (s.length) && (s[0] == '-'); + char[] a = neg ? s[1..$] : s; + foreach_reverse(c; a) { + i += (c-'0') * fac; + fac *= 10; + } + return !neg ? i : -i; +} + +void main() +{ + printf("64213 = %d\n", atoi("64213")); + printf("-64213 = %d\n", atoi("-64213")); + assert(atoi("64213") == 64213); + assert(atoi("-64213") == -64213); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug56.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module bug56; + +void main() +{ + int[] a; + a = [1,2,3]; + {int[] b = [4,5,6];} +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug59.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,20 @@ +module bug59; + +void main() +{ + int[2] a = 0; + //func(a); + a[0] = 1; + int i = a[0]; + int* p = &a[0]; +} + +void func(int[2] a) +{ + int* p = cast(int*)a; +} + +void func2(int[4] a) +{ + int* p = 3+cast(int*)a; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module bug6; +class wrong { } +void bark(ref wrong s) { s = new wrong; } +void foo(wrong tree) { + auto old = tree; + bark(tree); + assert(old !is tree); +} +void main() +{ + auto w = new wrong; + auto old = w; + foo(w); + assert(w is old); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug60.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module bug60; +extern(C) int printf(char*, ...); + +void func(T...)(T t) +{ + foreach(v;t) { + if (v.length) { + foreach(i;v) { + printf("%d\n", i); + } + } + } +} +void main() +{ + auto a = [1,2,3]; + func(a); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug61.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +module bug61; +extern(C) int printf(char*, ...); + +void main() +{ + int[3] a = [42,4,141414]; + printf("empty:\n"); + foreach(v; a[3..$]) { + printf("int = %d\n", v); + } + printf("one element:\n"); + foreach(v; a[2..$]) { + printf("int = %d\n", v); + } + printf("all elements:\n"); + foreach(v; a) { + printf("int = %d\n", v); + } + printf("empty reversed:\n"); + foreach_reverse(v; a[3..$]) { + printf("int = %d\n", v); + } + printf("all elements reversed:\n"); + foreach_reverse(v; a) { + printf("int = %d\n", v); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug62.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module bug62; +extern(C) int printf(char*, ...); + +void main() +{ + int[] arr = [1,2,5,7,9]; + int i = 0; + foreach(v; arr) { + i += v; + } + printf("sum = %d\n", i); + assert(i == 24); +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug63.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module bug63; +extern(C) int printf(char*, ...); + +void main() +{ + static void notnested() + { + printf("hello world\n"); + } + notnested(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug64.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module bug64; + +void main() +{ + float f; + float* p = &f; + float* end1 = p+1; + float* end2 = 1+p; + assert(end1 is end2); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +module bug7; + +class love { } +void bug() { + love[] child; + child.length=1; + assert(child[0] is null); + child[0]=null; + assert(child[0] is null); +} +void main() +{ + bug(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug70.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +module bug70; + +void main() +{ + for (;false;) + { + break; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug72.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module bug72; + +void main() +{ + char c = void; + int i = void; + c += i; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug73.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +int find(char[] s, dchar c) +{ + // c is a universal character + foreach (int i, dchar c2; s) + { + if (c == c2) + return i; + } + return -1; +} + +void main() +{ + char[] hello = "hello world"; + int i = find(hello, 'w'); + assert(i == 6); + i = find(hello, 'z'); + assert(i == -1); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug74.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module bug74; + +char[] sformat(char[] s, ...) +{ + TypeInfo[] ti = _arguments; + void* args = _argptr; + return ""; +} + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug75.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module bug75; + +void func(void delegate() dg) +{ +} + +void main() +{ + void nested() { + } + //func(&nested); + void delegate() dg = &nested; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug76.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +module bug76; +char[] fmt(...) +{ + return ""; +} +void main() +{ + char[] s = fmt(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug77.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,21 @@ +module bug77; + +extern(C) int strlen(char*); + +void main() +{ + size_t len; + void func2() + { + char* prefix = ""; + + void func() + { + len = strlen(prefix); + assert(len == 0); + } + + func(); + } + func2(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug78.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module bug78; + +void main() +{ + typedef int int_t = 42; + int_t i; + assert(i == int_t.init); +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug8.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,21 @@ +module bug8; + +void main() +{ + s = newS(); +} + +S* s; + +struct S +{ + int i; +} + +S* newS() +{ + auto tmp = new S; + tmp.i = 4; + return tmp; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug80.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module bug80; +extern(C) int printf(char*, ...); + +void main() +{ + byte b = 10; + int i = b += 2; + printf("byte=%d int=%d\n", b, i); + assert(b == 12); + assert(i == 12); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/bug9.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,34 @@ +module bug9; +extern(C) int printf(char*, ...); + +struct rgb +{ + ubyte[3] values; + rgb average(rgb other) + { + rgb res; + foreach (id, ref v; res.values) v=(values[id]+other.values[id])/2; + return res; + } + void print() + { + printf("[%d,%d,%d]\n", values[0], values[1], values[2]); + } +} + +void main() +{ + rgb a,b; + a.values[0] = 10; + a.values[1] = 20; + a.values[2] = 30; + b.values[0] = 30; + b.values[1] = 20; + b.values[2] = 10; + rgb avg = a.average(b); + avg.print(); + assert(avg.values[0] == 20); + assert(avg.values[1] == 20); + assert(avg.values[2] == 20); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/c.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module c; + +void main() +{ + ushort a = 0xFFF0; + ushort b = 0x0FFF; + auto t = a & b; + a &= b; + assert(t == a); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/callingconv1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,60 @@ +module mini.callingconv1; + +extern(C) int printf(char*, ...); + +float foo(float a, float b) +{ + return a + b; +} + +void main() +{ + float a = 1.5; + float b = 2.5; + float c; + + version(D_InlineAsm_X86) + { + version(Windows) + { + asm + { + movss XMM0, [a]; + movss XMM1, [b]; + movss [ESP], XMM1; + movss [ESP]+4, XMM0; + call foo; + fstp [c]-4; + movss XMM0, [c]-4; + movss [c], XMM0; + } + } else + { + + asm + { + mov EAX, [a]; + push EAX; + mov EAX, [b]; + push EAX; + call foo; + fstp c; + } + } + } + else version(D_InlineAsm_X86_64) + { + asm + { + movss XMM0, [a]; + movss XMM1, [b]; + call foo; + movss [c], XMM0; + } + } + printf("%f\n", c); + + assert(c == 4.0); + + printf("passed %f\n", c); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +extern(C) int printf(char*, ...); + +class C +{ + int i; + void p() + { + printf("%d\n", i); + } +} + +void main() +{ + printf("should print 4\n"); + C c = new C; + c.i = 4; + c.p(); + //delete c; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,37 @@ +module tangotests.classes1; + +class Outer +{ + int data; + + class Inner + { + long data; + + this(long d) + { + data = d*2; + } + } + + void func() + { + auto i = new Inner(data); + data += (i.data/4); + } + + this(int d) + { + data = d; + } +} + +void main() +{ + scope c = new Outer(100); + c.func(); + int d = c.data; + printf("150 = %d\n", d); +} + +extern(C) int printf(char*, ...);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes10.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module classes10; + +class C +{ + int i; + override char[] toString() + { + return "foobar"; + } +} + +void main() +{ + Object o = new C; + char[] s = o.toString(); + assert(s == "foobar"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes11.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,16 @@ +module classes11; +extern(C) int printf(char*, ...); + +void main() +{ + static class C + { + void func() + { + printf("Hello world\n"); + } + } + + scope c = new C; + c.func(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes12.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,34 @@ +class C +{ + int a; + union + { + int i; + double d; + } + int z; +} + +void func() +{ + scope c = new C; + access1(c); + assert(c.i == 42); + access2(c); + assert(c.d == 2.5); +} + +void access1(C c) +{ + c.i = 42; +} + +void access2(C c) +{ + c.d = 2.5; +} + +void main() +{ + func(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes13_bug239.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,28 @@ +extern(C) int printf(char*, ...); + +class A { + bool Afoo = false; + void foo() { Afoo = true; } +} + +class B : A {} + +class C : B { + bool Cfoo = false; + void foo() { Cfoo = true; } +} + +void main() +{ + scope c1 = new C(); + c1.foo(); + assert(c1.Cfoo && !c1.Afoo); + + scope c2 = new C(); + c2.B.foo(); + assert(!c2.Cfoo && c2.Afoo); + + scope c3 = new C(); + c3.A.foo(); + assert(!c3.Cfoo && c3.Afoo); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,25 @@ +extern(C) int printf(char*, ...); + +class A +{ + int i; + void f() + { + printf("A.f\n"); + } +} + +class B : A +{ + long l; + void f() + { + printf("B.f\n"); + } +} + +void main() +{ + A a = new B; + a.f(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,33 @@ +class C +{ + int c; + long f(long l) + { + return l; + } +} + +class D : C +{ + int d; + override long f(long l) + { + return l*2; + } +} + +void main() +{ + scope c = new C; + assert(c.f(25L) == 25); + scope d = new D; + assert(d.f(25L) == 50); + C cd = d; + assert(cd.f(25L) == 50); + assert(func(d,25L) == 50); +} + +long func(C c, long l) +{ + return c.f(l); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,38 @@ +extern(C) int printf(char*, ...); + +class A +{ + int i = 42; + double df = 3.1415; + this() + { + } + char[] toString() + { + return "A:Object"; + } +} + +class B : A +{ + ubyte b; + char[] toString() + { + return "B:A"; + } +} + +void main() +{ + scope a = new A; + char[] as = a.toString; + {printf("a.toString = '%.*s'\n", as.length, as.ptr);} + + Object o = a; + char[] os = o.toString; + {printf("o.toString = '%.*s'\n", os.length, os.ptr);} + + scope b = new B; + char[] bs = b.toString; + {printf("b.toString = '%.*s'\n", bs.length, bs.ptr);} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,24 @@ +module classes5; +extern(C) int printf(char*, ...); + +struct S +{ + long l; +} + +class C +{ + C c; + S s; +} + +void main() +{ + C c = new C; + long* lp = void; + {c.s.l = 64;} + {assert(c.s.l == 64);} + {lp = &c.s.l;} + {assert(*lp == 64);} + printf("classes5 success\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,38 @@ +module classes6; +extern(C) int printf(char*, ...); + +class C +{ + void f() + { + printf("world\n"); + } +} + +class D : C +{ + void f() + { + printf("moon\n"); + } +} + + +extern(C) +{ + void srand(uint seed); + int rand(); +} + +import ldc.intrinsics; + +void main() +{ + C c; + srand(readcyclecounter()); + if (rand() % 2) + c = new C; + else + c = new D; + c.f(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,21 @@ +module classes7; + +class C +{ + int i=0; + void f() + { + i=42; + } + void g() + { + f(); + } +} + +void main() +{ + scope c = new C; + c.g(); + assert(c.i == 42); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes8.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,22 @@ +class A { + int i; + int l; + this(bool b,bool b2=false) { + if (b) this = new B; + i = 4; + if (b2) this = new C; + l = 64; + } +} +class B : A{ + this() { + super(false); + } +} +class C : A{ + this() { + super(false); + } +} +void main() { +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classes9.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,47 @@ +module classes9; + +class C +{ +} + +class D : C +{ +} + +class E +{ +} + +class F : E +{ +} + +void main() +{ + { + D d = new D; + { + C c = d; + assert(c !is null); + D d2 = cast(D)c; + assert(d2 !is null); + E e = cast(E)d; + assert(e is null); + F f = cast(F)d; + assert(f is null); + } + } + { + F f = new F; + { + E e = f; + assert(e !is null); + F f2 = cast(F)e; + assert(f2 !is null); + C c = cast(C)f; + assert(c is null); + D d2 = cast(D)f; + assert(d2 is null); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classinfo1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,30 @@ +module classinfo1; + +extern(C) int printf(char*, ...); + +class NoPtrs +{ +} + +class HasPtrs +{ + void* p; +} + +void main() +{ + { + ClassInfo ci = NoPtrs.classinfo; + char[] name = ci.name; + printf("%.*s\n", name.length, name.ptr); + assert(ci.name == "classinfo1.NoPtrs"); + assert(ci.flags & 2); + } + { + ClassInfo ci = HasPtrs.classinfo; + char[] name = ci.name; + printf("%.*s\n", name.length, name.ptr); + assert(ci.name == "classinfo1.HasPtrs"); + assert(!(ci.flags & 2)); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classinfo2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module classinfo2; + +class C +{ +} + +class D : C +{ +} + +void main() +{ + D d; + d = new D; + ClassInfo ci = d.classinfo; + assert(ci is D.classinfo); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classinfo3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,29 @@ +module classinfo3; + +class C +{ + int i; + float f; + long l; + int j; +} + +void main() +{ + auto c = C.classinfo; + if (c.offTi !is null) + { + assert(c.offTi.length == 4); + + size_t base = 2*size_t.sizeof; + + assert(c.offTi[0].offset == base); + assert(c.offTi[0].ti == typeid(int)); + assert(c.offTi[1].offset == base+4); + assert(c.offTi[1].ti == typeid(float)); + assert(c.offTi[2].offset == base+8); + assert(c.offTi[2].ti == typeid(long)); + assert(c.offTi[3].offset == base+16); + assert(c.offTi[3].ti == typeid(int)); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classinfo4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,43 @@ +module classinfo4; + +class C +{ +} + +class D : C +{ + this() + { + } + ~this() + { + } +} + +template T() +{ + ~this() + { + } +} + +class E : D +{ + this() + { + } + ~this() + { + } + mixin T; +} + +void main() +{ + assert(C.classinfo.defaultConstructor is null); + assert(C.classinfo.destructor is null); + assert(D.classinfo.defaultConstructor !is null); + assert(D.classinfo.destructor !is null); + assert(E.classinfo.defaultConstructor !is null); + assert(E.classinfo.destructor !is null); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/classinfo5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +extern(C) int printf(char*, ...); + +class BaseClass {} + +void main() +{ + Object o_cr = BaseClass.classinfo.create(); + Object o_new = new BaseClass; + printf("CIaddr: %X\n", cast(size_t*)BaseClass.classinfo); + printf("Create: %X\n", cast(size_t*)o_cr.classinfo); + printf("New: %X\n", cast(size_t*)o_new.classinfo); + assert(cast(size_t*)o_cr.classinfo == cast(size_t*)o_new.classinfo); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/comma.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module comma; + +void main() +{ + int i=0,j=0; + for (; i<10; i++,j++) + { + } + assert(i == 10); + assert(j == 10); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_asm1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +extern(C) int printf(char*, ...); +void main() +{ + void* i; + asm + { + mov EAX, FS:4; + mov i, EAX; + } + printf("FS:4 = %p\n", i); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_asm_fpinstr_compare.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,31 @@ +void main() { +asm { + fmul; + fmul ST, ST(1); + fmul ST(1), ST; + fmulp; + fmulp ST(1), ST; + + fdiv; + fdiv ST, ST(1); + fdiv ST(1), ST; + fdivp; + fdivp ST(1), ST; + fdivr; + fdivr ST, ST(1); + fdivr ST(1), ST; + fdivrp; + fdivrp ST(1), ST; + + fsub; + fsub ST, ST(1); + fsub ST(1), ST; + fsubp; + fsubp ST(1), ST; + fsubr; + fsubr ST, ST(1); + fsubr ST(1), ST; + fsubrp; + fsubrp ST(1), ST; +} +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_bug164_stringinitcast.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,2 @@ +const C = "foo"; +char[] var = C;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_bug174_enclosing_on_break.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,5 @@ +void main() +{ + scope Object o; + switch(0) {} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_bug26.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module bug26; + +extern int i; + +void main() +{ + int j = i; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_bug305.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +module bug305; + +class E { + void A() { + alias E m; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_bug_ldc_154.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +template toInt(char[4] arg) +{ + const uint toInt = (cast(uint[]) arg)[0]; + } + + void main() + { + auto i = toInt!("abcd"); + }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_ctfe_dup.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,4 @@ +char[] foobar() { + return "foobar".dup; +} +const char[] foo = foobar();
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_delegate.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +class A(T) +{ + void foo(void delegate (T) d) {} + + void bar() + { + foo(delegate void (T t) {}); + } +} + +class B: A!(B) {} + +class C: A!(C) {}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_delegatetuple.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +alias char[] string; +template Unstatic(T) { alias T Unstatic; } +template Unstatic(T: T[]) { alias T[] Unstatic; } +template StupleMembers(T...) { + static if (T.length) { + const int id=T[0..$-1].length; + const string str=StupleMembers!(T[0..$-1]).str~"Unstatic!(T["~id.stringof~"]) _"~id.stringof~"; "; + } else const string str=""; +} + +struct Stuple(T...) { + mixin(StupleMembers!(T).str); +} +Stuple!(string, void delegate(float)) foo;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_funcptr1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,4 @@ +module mini.compile_funcptr1; + +void a() { } +void function() b = &a;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_nested1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,1 @@ +void append(lazy char[] exp) { char[] s = exp; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_nested2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +void test(void delegate() spam) +{ + static void foo() // static is the problem + { + uint x; + void peek() { x = 0; } + } + + void bar() + { + spam(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_rawvardeclinfinally.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +void foo() { + void delegate()[] bar; + try { + } finally { + foreach (dg; bar) + dg(); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_scope_exit_foreach.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +module scope_exit_foreach; + +void bar(size_t); + +long foo(ubyte[] arr) { + scope(exit) { + foreach (ref b; arr) { + bar(b); + } + } + if (arr.length == 3) + return 0; + return arr.length; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/compile_structs1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,4 @@ +struct Foo { int a, b, c; union Data { } Data data; } +struct Bar { int a, b; } +struct Baz { int a; union { Foo foo; Bar bar; } } +void test() { Baz baz; if (baz.bar.a) return; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/complex1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module complex1; + +void main() +{ + cfloat cf1 = 3f + 0i; + cfloat cf2 = 4f + 1i; + cfloat cf3 = func(); + auto c1 = cf1 + cf2; + auto c2 = cf2 - cf3; + auto c3 = cf1 * cf3; + auto c4 = cf2 / cf3; +} + +cfloat func() +{ + return 3f + 1i; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/complex2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module complex2; + +void main() +{ + cdouble c = 3.0 + 0i; + cdouble d = 2.0 + 0i; + cdouble c1 = c + 3.0; + cdouble c2 = c - 3.0i; + cdouble c3 = c / 2.0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/complex3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +module complex3; + +void main() +{ + cfloat c1 = 1f + 0i; + cfloat c2 = 0f + 0i; + c2 += 1f + 0i; + assert(c1 == c2); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/complex4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module complex4; + +void main() +{ + cfloat c = 2f + 3fi; + float r = cast(float)c; + ifloat i = cast(ifloat)c; +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/complex5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module complex5; + +void main() +{ + cfloat c = 3+2i; + foo(c); +} + +void foo(cfloat c) +{ + assert(c.re > 2.9999 && c.re < 3.0001); + assert(c.im > 1.9999i && c.im < 2.0001i); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/cond.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,45 @@ +extern(C) int printf(char*, ...); + +version=AndAnd; +version=OrOr; + +version(AndAnd) +void andand1() +{ + int a,b; + a = 4; + b = 5; + assert(a == 4); + assert(b == 5); + assert(a+b == 9); + assert(a == 4 && b == 5); + assert(a != 3 && b == 5); + assert(a > 2); + assert(a < 54); + assert(a < b); + assert(a > b-2); + + int apb = a+b; + int amb = a*b; + assert(apb < amb && apb > a); +} + +version(OrOr) +void oror1() +{ + int a,b; + a = 10; + b = 1000; + assert(a); + assert(b); + assert(a || b); + assert(a > b || a < b); +} + +void main() +{ + printf("Conditionals test\n"); + version(AndAnd) andand1(); + version(OrOr) oror1(); + printf(" SUCCESS\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/cond1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module cond1; + +void main() +{ + double a = 2; + double b = 4; + double c = (a > 0) ? a : b; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/condexp.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +module condexp; + +int f() +{ + return 42; +} + +void main() +{ + int i = f() < 25 ? -1 : 1; + /*int j = f() > 25 ? 1 : -1; + assert(i); + assert(!j);*/ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/condexp1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module condexp1; + +void main() +{ + char[] a = "hello"; + char[] b = "world"; + int i = 42; + { + char[] c = i > 50 ? b : a; + assert(c is a); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/const1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module mini.const1; + +void* g = cast(void*)&foobar; + +int foobar() +{ + return 42; +} + +void main() +{ + auto fn = cast(int function())g; + int i = fn(); + assert(i == 42); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/const2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +int[10] test; +int* t = &test[3]; + +void main() +{ + assert(t is &test[3]); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/conststructliteral.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +struct S { int i; } + +const S s1; +static this() { s1 = S(5); } +const S s2 = { 5 }; +const S s3 = S(5); +S foo() { S t; t.i = 5; return t; } +const S s4 = foo(); + +const ps1 = &s1; +const ps2 = &s2; +//const ps3 = &s3; // these could be made to work +//const ps4 = &s4; + +extern(C) int printf(char*,...); +void main() { + printf("%p %p\n", ps1, ps2); + printf("%p %p %p %p\n", &s1, &s2, &s3, &s4); + + assert(ps1 == ps1); + assert(ps2 == ps2); + assert(&s1 == &s1); + assert(&s2 == &s2); + assert(&s3 == &s3); + assert(&s4 == &s4); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/cyclic.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,16 @@ +void main() +{ + S t; +} + +struct T +{ + int i; + S* s; +} + +struct S +{ + long i; + T* t; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/d.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,50 @@ +module d; + +void main() +{ + int delegate() dg; + + struct S + { + int i; + long l; + float f; + + int func() + { + return 42; + } + } + + S s; + auto dg2 = &s.func; + int i = dg2(); + assert(i == 42); + + i = f(dg2, 1); + assert(i == 43); +} + +int f(int delegate() dg, int i) +{ + return dg() + i; +} + +/* +struct S +{ + int i; + float f; + int square() + { + return i*i; + } +} + +S s; + +void main() +{ + auto dg = &s.square; +} +*/ \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/delegate.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +class C { void foo() {} } + +void main() +{ + C c = new C; + void delegate() dlg = &c.foo; + + assert(dlg); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/delegate2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module mini.delegate2; + +void main() +{ + int foo = 42; + int bar() + { + return foo; + } + int delegate() dg = &bar; + assert(dg() == foo); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/delegate3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module bar; + +class S +{ + int i; + final int foo() + { + return i; + } +} + +void main() +{ + auto s = new S; + s.i = 42; + auto dg = &s.foo; + assert(dg() == 42); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/dgfuncptr.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +void main() +{ + void foo() {} + + auto dg = &foo; + + if(dg.funcptr is null) + { assert(0); } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/dgs.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,87 @@ + +extern(C) int printf(char*, ...); + +struct S +{ + int i; + int square() + { + return i*i; + } + int plus(int a) + { + return i + a; + } + int minus(int a) + { + return i - a; + } + int delegate(int) get(char op) + { + int delegate(int) rval; + if (op == '+') + rval = + + else if (op == '-') + rval = − + return rval; + } +} + +int calldg1(int delegate(int) dg, int i) +{ + return dg(i); +} + +void delegate() retdg() +{ + void delegate() dg; + return dg; +} + +void getretdg() +{ + void delegate() dg; + dg = retdg(); +} + +class C +{ + int i; + void m() + { + i = 42; + } +} + +void getclassdg() +{ + scope c = new C; + void delegate() dg = &c.m; + assert(c.i != 42); + dg(); + assert(c.i == 42); +} + +void main() +{ + printf("Delegate test\n"); + S s = S(4); + + auto dg = &s.square; + //assert(dg() == 16); + //dg(); + + /*auto dg1 = &s.plus; + assert(dg1(6) == 10); + + auto dg2 = &s.minus; + assert(calldg1(dg2,30) == -26); + + auto dg3 = s.get('+'); + assert(dg3(16) == 20); + + getretdg(); + getclassdg();*/ + + printf(" SUCCESS\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/dotproduct.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,36 @@ +extern(C) int printf(char*, ...); + +struct vec3 +{ + float x,y,z; + + float dot(ref vec3 v) + { + return x*v.x + y*v.y + z*v.z; + } + + void print(char[] n) + { + printf("%.*s = vec3(%.4f, %.4f, %.4f)\n", n.length, n.ptr, x,y,z); + } +} + +int main() +{ + printf("Dot Product test\n"); + + const f = 0.7071067811865474617; + vec3 v = vec3(f,f,0); + vec3 w = vec3(f,0,f); + + v.print("v"); + w.print("w"); + + auto dp = v.dot(w); + printf("v · w = %f\n", dp); + assert(dp > 0.4999 && dp < 0.5001); + + printf(" SUCCESS\n"); + return 0; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/dottypeexp.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,4 @@ +extern(C) int printf(char*, ...); +template Foo() { void test() { printf("test\n"); typeof(this).whee(); } } +class Bar { void whee() { printf("whee\n"); } mixin Foo!(); } +void main() { (new Bar).test(); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/e.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,25 @@ +module e; + +extern(C) int printf(char*, ...); + +struct C +{ + float x=0,y=0; + + float dot(ref C b) + { + return x*b.x + y*b.y; + } +} + +void main() +{ + C a,b; + a.x = 2; + a.y = 6; + b.x = 3; + b.y = 5; + float f = a.dot(b); + printf("%f\n", f); + assert(f == 36); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/emptytuple.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +template T(B...) { + typedef B TArgs; +} + +int main(){ + alias T!() instantiate; + return 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/enum1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module enum1; + +void main() +{ + enum { + HELLO, + WORLD + } + + assert(HELLO == 0); + assert(WORLD == 1); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/enum2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module enum2; + +void main() +{ + enum E { + A,B + } + E e = E.B; + assert(e == E.B); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/enum3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module enum3; + +enum GE : ushort +{ + A,B,C +} + +void main() +{ + GE e = GE.B; + size_t s = GE.sizeof; + assert(e == 1); + assert(e.sizeof == s); + assert(s == 2); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/f.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module f; + +struct S +{ + long l; +} + +void main() +{ + S s; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/floatcmp.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,161 @@ +module floatcmp; +extern(C) int printf(char*, ...); + +void eq() +{ + float _3 = 3; + assert(!(_3 == 4)); + assert(!(_3 == 2)); + assert(_3 == 3); + assert(!(_3 == float.nan)); +} + +void neq() +{ + float _3 = 3; + assert(_3 != 4); + assert(_3 != 2); + assert(!(_3 != 3)); + assert(_3 != float.nan); +} + +void gt() +{ + float _3 = 3; + assert(_3 > 2); + assert(!(_3 > 4)); + assert(!(_3 > 3)); + assert(!(_3 > float.nan)); +} + +void ge() +{ + float _3 = 3; + assert(_3 >= 2); + assert(!(_3 >= 4)); + assert(_3 >= 3); + assert(!(_3 >= float.nan)); +} + +void lt() +{ + float _3 = 3; + assert(_3 < 4); + assert(!(_3 < 2)); + assert(!(_3 < 3)); + assert(!(_3 < float.nan)); +} + +void le() +{ + float _3 = 3; + assert(_3 <= 4); + assert(!(_3 <= 2)); + assert(_3 <= 3); + assert(!(_3 <= float.nan)); +} + +void uno() +{ + float _3 = 3; + assert(!(_3 !<>= 2)); + assert(!(_3 !<>= 3)); + assert(!(_3 !<>= 4)); + assert(_3 !<>= float.nan); +} + +void lg() +{ + float _3 = 3; + assert(_3 <> 4); + assert(_3 <> 2); + assert(!(_3 <> 3)); + assert(!(_3 <> float.nan)); +} + +void lge() +{ + float _3 = 3; + assert(_3 <>= 4); + assert(_3 <>= 2); + assert(_3 <>= 3); + assert(!(_3 <>= float.nan)); +} + +void ugt() +{ + float _3 = 3; + assert(_3 !<= 2); + assert(!(_3 !<= 4)); + assert(!(_3 !<= 3)); + assert(_3 !<= float.nan); +} + +void uge() +{ + float _3 = 3; + assert(_3 !< 2); + assert(!(_3 !< 4)); + assert(_3 !< 3); + assert(_3 !< float.nan); +} + +void ult() +{ + float _3 = 3; + assert(_3 !>= 4); + assert(!(_3 !>= 2)); + assert(!(_3 !>= 3)); + assert(_3 !>= float.nan); +} + +void ule() +{ + float _3 = 3; + assert(_3 !> 4); + assert(!(_3 !> 2)); + assert(_3 !> 3); + assert(_3 !> float.nan); +} + +void ueq() +{ + float _3 = 3; + assert(!(_3 !<> 2)); + assert(!(_3 !<> 4)); + assert(_3 !<> 3); + assert(_3 !<> float.nan); +} + +void main() +{ + printf("floating point comparison test\n"); + + eq(); + neq(); + gt(); + ge(); + lt(); + le(); + uno(); + lg(); + lge(); + ugt(); + uge(); + ult(); + ule(); + ueq(); + + printf(" SUCCESS\n"); +} + +/+ +void gt() +{ + float _3 = 3; + assert(); + assert(); + assert(); + assert(); +} ++/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/foreach1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module foreach1; +extern(C) int printf(char*, ...); + +void main() +{ + static arr = [1,2,3,4,5]; + + printf("forward"); + foreach(v;arr) { + printf(" %d",v); + } + printf("\nreverse"); + foreach_reverse(v;arr) { + printf(" %d",v); + } + printf("\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/foreach10.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +module foreach10; + +extern(C) int printf(char*, ...); + +void main() { + char* last = null; + printf("The addresses should increment:\n"); + foreach (ref c; "bar") { + auto a = { + printf("%x '%c'\n", c, c); + return &c; + }; + auto nw = a(); + printf("ptr = %p\n", nw); + if (last != null) + assert(nw == last+1); + last = nw; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/foreach11.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module foreach11; + +extern(C) int printf(char*, ...); + +void main() { + char* last = null; + printf("The addresses should remain constant:\n"); + foreach (c; "bar") { + auto a = { + printf("%x '%c'\n", c, c); + printf("ptr = %p\n", &c); + if (last) + assert(last == &c); + }; + a(); + last = &c; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/foreach2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module foreach2; +extern(C) int printf(char*, ...); +void main() +{ + static arr = [1.0, 2.0, 4.0, 8.0, 16.0]; + foreach(i,v; arr) + { + printf("arr[%d] = %f\n", i, v); + } + printf("-------------------------------\n"); + foreach_reverse(i,v; arr) + { + printf("arr[%d] = %f\n", i, v); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/foreach3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +module foreach3; +extern(C) int printf(char*, ...); +void main() +{ + static str = ['h','e','l','l','o']; + foreach(i,v; str) { + printf("%c",v); + } + printf("\n"); + + foreach(i,v; str) { + v++; + } + + foreach(i,v; str) { + printf("%c",v); + } + printf("\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/foreach4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +module foreach4; +extern(C) int printf(char*, ...); +void main() +{ + int[] arr = new int[4]; + foreach(i,v;arr) { + printf("arr[%u] = %d\n",i,v); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/foreach5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,24 @@ +module foreach5; +extern(C) int printf(char*, ...); +void main() +{ + int[3] arr = [1,2,3]; + + foreach(v;arr) { + v++; + } + + printf("%d\n", arr[0]); + assert(arr[0] == 1); + assert(arr[1] == 2); + assert(arr[2] == 3); + + foreach(ref v;arr) { + v++; + } + + printf("%d\n", arr[0]); + assert(arr[0] == 2); + assert(arr[1] == 3); + assert(arr[2] == 4); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/foreach6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module mini.foreach6; + +struct S +{ + long l; + float f; +} + +void main() +{ + S[4] arr = void; + foreach(i,v;arr) { + v = S(i, i*2.5); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/foreach7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module foreach7; + +void main() +{ + int[4] a = [1,2,3,4]; + int i; + foreach(v; a[0..3]) + { + i += v; + } + assert(i == 6); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/foreach8.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +module mini.foreach8; + +extern(C) int printf(char*, ...); + +int main(){ + dchar[] array="\u2260"; + printf("array[0] == %u\n", array[0]); + int test=0; + int count=0; + assert(count==0); + foreach(int index, char obj; array){ + printf("%d\n", obj); + test+=obj; + count++; + } + assert(count==3); + assert(test==0x20b); + return 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/foreach9.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,24 @@ +module mini.foreach9; +extern(C) int printf(char* str, ...); + +struct array2d(T) { + int test() { + printf("%p\n", cast(void*) this); + foreach (x; *this) { + printf("%p\n", cast(void*) this); + } + return true; + } + int opApply(int delegate(ref int) dg) { + int x; + return dg(x), 0; + } +} + +unittest { + array2d!(int) test; + test.test(); + //int i = 0; i /= i; +} + +void main() { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/forwdecl.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +struct S +{ + S* s; + S** ss; + S*[4] s4; +} + +void main() +{ + S s; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/forwdecl1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +struct Foo; + +Foo* foo() +{ + return null; +} + +void main() +{ + Foo* f = foo(); + assert(f is null); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/funcptr.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,68 @@ +extern(C) int printf(char*, ...); + +int return_six() +{ + return 6; +} + +int add_int(int a, int b) +{ + return a+b; +} + +int sub_int(int a, int b) +{ + return a-b; +} + +alias int function(int,int) binfn_t; + +int binop_int(binfn_t op, int a, int b) +{ + return op(a,b); +} + +binfn_t get_binop_int(char op) +{ + binfn_t fn; + if (op == '+') + fn = &add_int; + else if (op == '-') + fn = &sub_int; + return fn; +} + +extern(C) float mul_float(float a, float b) +{ + return a * b; +} + +void function_pointers() +{ + int function() fn = &return_six; + assert(fn() == 6); + + binfn_t binfn = &add_int; + assert(binfn(4,1045) == 1049); + + assert(binop_int(binfn, 10,656) == 666); + + binfn = get_binop_int('+'); + assert(binop_int(binfn, 10,100) == 110); + binfn = get_binop_int('-'); + assert(binop_int(binfn, 10,100) == -90); + + { + auto ffn = &mul_float; + float ftmp = mul_float(2.5,5); + assert(ftmp == 12.5); + assert(ftmp > 12.49 && ftmp < 12.51); + } +} + +void main() +{ + printf("Function pointer test\n"); + function_pointers(); + printf(" SUCCESS\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/funcs.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,50 @@ +extern(C) int printf(char*, ...); + +void main() +{ + printf("Testing functions\n"); + int i = 5; + assert(a(i) == 110); + assert(i == 11); + + S s; + s.i = 5; + d(s); + assert(s.i == 5); + e(s); + assert(s.i == 6); + + printf(" SUCCESS\n"); +} + +int a(ref int i) +{ + i*=2; + return b(i); +} + +int b(ref int i) +{ + i++; + return c(i); +} + +int c(int i) +{ + return i*10; +} + +struct S +{ + int i; +} + +void d(S s) +{ + s.i++; +} + +void e(ref S s) +{ + s.i++; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/funcs2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +module funcs2; + +void func() +{ +} + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/g.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module g; + +extern(C) int printf(char*, ...); + +void func(char[] str) +{ + printf("%.*s\n", str.length, str.ptr); +} + +void main() +{ + char[] arr = "Hello World!"; + func(arr); + func("ditto"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/gc1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module tangotests.gc1; + +void main() +{ + int[] arr; + + for (int i=0; i<100; ++i) + { + arr ~= new int[1000]; + } + + printf("arr.length = %u\n", arr.length); +} + +extern(C) int printf(char*, ...); \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/gc_datasegment.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +extern(C) void gc_collect(); + +class C +{ + int i = 42; +} + +C data; + +void main() +{ + data = new C; + gc_collect(); + assert(data.i == 42); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/globals1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module globals1; +extern(C) int printf(char*, ...); + +char[] gstr = "hello world"; + +void main() +{ + printf("%.*s\n", gstr.length, gstr.ptr); + char[] str = gstr; + printf("%.*s\n", str.length, str.ptr); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/globals2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module globals2; + +template Bool(bool b) +{ + const bool Bool = b; +} + +void main() +{ + assert(Bool!(true)); + assert(!Bool!(false)); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/goto1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module goto1; + +void main() +{ + int i; + goto lbl; + i++; +lbl: + assert(i == 0); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/h.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +interface Iin +{ + void[] read(size_t n); +} + +interface Iout +{ + size_t write(void[] d); +} + +class C : Iin +{ + void[] read(size_t n) + { + return null; + } + + size_t write(void[] d) + { + return 0; + } +} + +void main() +{ + scope c = new C; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/i.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,20 @@ +interface IN +{ + void func(); +} +abstract class AC +{ + abstract void func(); + long ll; +} +class C : AC +{ + void func() + { + } +} + +void main() +{ + scope c = new C; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/imag1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +module imag1; + +void main() +{ + ifloat f = 1.0i; + auto x = 2.0i*f; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/innerclass1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,30 @@ +module innerclass1; +extern(C) int printf(char*, ...); + +class Outer +{ + int i; + class Inner + { + int func() + { + return i; + } + } +} + +void main() +{ + Outer o = new Outer; + { + o.i = 42; + { + auto i = o.new Inner; + { + int x = i.func(); + assert(x == 42); + } + } + } + printf("SUCCESS\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/interface1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,24 @@ +module interface1; + +extern(C) int printf(char*,...); + +interface Inter +{ + void func(); +} + +class Class : Inter +{ + override void func() + { + printf("hello world\n"); + } +} + +void main() +{ + scope c = new Class; + c.func(); + Inter i = c; + i.func(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/interface2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,37 @@ +module interface2; + +extern(C) int printf(char*,...); + +interface A +{ + void a(); +} + +interface B +{ + void b(); +} + +class C : A,B +{ + int i = 0; + override void a() + { + printf("hello from C.a\n"); + } + override void b() + { + printf("hello from C.b\n"); + } +} + +void main() +{ + scope c = new C; + {c.a(); + c.b();} + {A a = c; + a.a();} + {B b = c; + b.b();} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/interface3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,30 @@ +module interface3; + +extern(C) int printf(char*,...); + +interface I +{ + void func(); +} + +class C : I +{ + int i = 42; + override void func() + { + printf("hello %d from %p\n", i, this); + i++; + } +} + +void main() +{ + auto c = new C; + {c.func();} + { + I i = c; + {i.func();} + } + {printf("final %d\n", c.i);} + {assert(c.i == 44);} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/interface4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,35 @@ +module interface4; + +extern(C) int printf(char*,...); + +interface I +{ + void func(); +} + +interface I2 +{ + void func(); +} + +class C : I,I2 +{ + int i = 42; + override void func() + { + printf("hello %d\n", i); + i++; + } +} + +void main() +{ + scope c = new C; + c.func(); + I i = c; + i.func(); + I2 i2 = c; + i2.func(); + printf("final %d\n", c.i); + assert(c.i == 45); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/interface5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,34 @@ +module interface5; + +extern(C) int printf(char*,...); + +interface I +{ + void func(); +} + +class C : I +{ + int i; + void func() + { + printf("C\n"); + i++; + } +} + +void main() +{ + C c = new C; + c.func(); + { + I i = c; + i.func(); + + C c2 = cast(C)i; + c2.func(); + + c.func(); + assert(c.i == 4); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/interface6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,46 @@ +module interface6; + +extern(C) int printf(char*,...); + +interface I +{ + void Ifunc(); +} + +interface J +{ + void Jfunc(); +} + +class C : I,J +{ + int i; + int j; + void Ifunc() + { + i++; + } + void Jfunc() + { + j++; + } +} + +void main() +{ + C c = new C; + c.Ifunc(); + c.Jfunc(); + I i = c; + i.Ifunc(); + J j = c; + j.Jfunc(); + C c2 = cast(C)i; + c2.Ifunc(); + c2.Jfunc(); + C c3 = cast(C)j; + c3.Ifunc(); + c3.Jfunc(); + assert(c.i == 4); + assert(c.j == 4); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/interface7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,23 @@ +module interface7; + +extern(C) int printf(char*,...); + +interface I +{ +} + +class C : I +{ +} + +void main() +{ + I i = new C; + ClassInfo ci = i.classinfo; + char[] name = ci.name; + printf("ci.name = %.*s\n", name.length, name.ptr); + ClassInfo cI = I.classinfo; + name = cI.name; + printf("cI.name = %.*s\n", name.length, name.ptr); + assert(ci is cI); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/interface8.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,59 @@ +interface InputStream +{ + void foo(); +} + +interface OutputStream +{ + void bar(); +} + +interface IConduit : InputStream, OutputStream +{ + abstract uint bufferSize(); +} + +class Conduit : IConduit +{ + abstract uint bufferSize(); + abstract void foo(); + abstract void bar(); +} + +interface Selectable +{ + void car(); +} + +class DeviceConduit : Conduit, Selectable +{ + override uint bufferSize () + { + return 1024 * 16; + } + override void foo() {} + override void bar() {} + override void car() {} + int handle; +} + +class ConsoleConduit : DeviceConduit +{ + override void foo() {} + bool redirected; +} + +class OtherConduit : Conduit +{ + abstract uint bufferSize(); + override void foo() {} + override void bar() {} +} + +void main() +{ + auto c = new ConsoleConduit; + IConduit ci = c; + assert(c.bufferSize == ci.bufferSize); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/intrinsics.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,28 @@ +import ldc.intrinsics; + +extern(C) int printf(char*,...); +extern(C) int scanf(char*,...); + +void main() +{ + float f; + printf("Enter float: "); + //scanf("%f", &f); + f = 1.22345; + float sf = llvm_sqrt(f); + printf("sqrt(%f) = %f\n", f, sf); + + double d; + printf("Enter double: "); + //scanf("%lf", &d); + d = 2.2311167895435245; + double sd = llvm_sqrt(d); + printf("sqrt(%lf) = %lf\n", d, sd); + + real r; + printf("Enter real: "); + //scanf("%llf", &r); + r = 3.2311167891231231234754764576; + real sr = llvm_sqrt(r); + printf("sqrt(%Lf) = %Lf\n", r, sr); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/intrinsics_ovf.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,77 @@ +module intrinsics_ovf; + + +//version = PRINTF; + +version(PRINTF) + extern(C) int printf(char*, ...); + + +import ldc.intrinsics; + + +int saddo(int a, int b, out bool overflow) { + auto Result = llvm_sadd_with_overflow(a, b); + overflow = Result.overflow; + return Result.result; +} + +int uaddo(int a, int b, out bool overflow) { + auto Result = llvm_uadd_with_overflow(a, b); + overflow = Result.overflow; + return Result.result; +} + +int smulo(int a, int b, out bool overflow) { + auto Result = llvm_smul_with_overflow(a, b); + overflow = Result.overflow; + return Result.result; +} + +/* +uint umulo(uint a, uint b, out bool overflow) { + auto Result = llvm_umul_with_overflow(a, b); + overflow = Result.overflow; + return Result.result; +} +*/ + +void test(int function(int, int, out bool) fn, + int a, int b, int result_e, bool ovf_e) { + version(PRINTF) + printf("%8x :: %8x :: %8x :: %.*s\n", a, b, result_e, + (ovf_e ? "true" : "false")); + + bool ovf; + int result = fn(a, b, ovf); + + version(PRINTF) + printf("____________________ %8x :: %.*s\n", result, + (ovf ? "true" : "false")); + + assert(ovf == ovf_e); + assert(result == result_e); +} + +void main() { + test(&saddo, int.min, int.min, int.min + int.min, true); + test(&saddo, int.min, int.max, int.min + int.max, false); + test(&saddo, 1, int.max, 1 + int.max, true); + test(&saddo, 1, 2, 3, false); + test(&saddo, -1, -2, -3, false); + + test(&uaddo, 0, uint.max, 0 + uint.max, false); + test(&uaddo, 1, uint.max, 1 + uint.max, true); + test(&uaddo, 1, 2, 3, false); + + test(&smulo, int.min, int.min, int.min * int.min, true); + test(&smulo, int.min, int.max, int.min * int.max, true); + test(&smulo, int.max, int.max, int.max * int.max, true); + test(&smulo, 1, int.max, 1 * int.max, false); + test(&smulo, 2, int.max/2, 2 * (int.max/2), false); + test(&smulo, 2, int.max/2 + 1, 2 * (int.max/2 + 1), true); + test(&smulo, 2, int.min/2, 2 * (int.min/2), false); + test(&smulo, 2, int.min/2 - 1, 2 * (int.min/2 - 1), true); + test(&smulo, 1, 2, 2, false); + test(&smulo, -1, -2, 2, false); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/j.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,44 @@ +module j; + +interface Inter1 +{ + int func1(); +} + +interface Inter2 +{ + int func2(); +} + +class C12 : Inter1, Inter2 +{ + int func1() + { + return 1; + } + int func2() + { + return 2; + } +} + +void func(Object c) +{ + auto i1 = cast(Inter1)c; + assert(i1.func1() == 1); + auto i2 = cast(Inter2)c; + assert(i2.func2() == 2); + auto j1 = cast(Inter1)i2; + assert(j1.func1() == 1); + auto j2 = cast(Inter2)i1; + assert(j2.func2() == 2); +} + +void main() +{ + scope c = new C12; + func(c); + printf("OK\n"); +} + +extern(C) int printf(char*,...);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/k.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,31 @@ +interface Inter +{ + int func(); +} + +extern(C) int printf(char*, ...); + +class InterClass : Inter +{ + int func() + { + return printf("InterClass.func()\n"); + } +} + +alias int delegate() dg_t; + +void main() +{ + scope c = new InterClass; + + { + Inter i = cast(Inter)c; + { + dg_t dg = &i.func; + { + int j = dg(); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/lazy1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module tangotests.lazy1; + +extern(C) int printf(char*, ...); + +void main() +{ + lazystr("whee\n"); +} + +void lazystr(lazy char[] msg) +{ + printf("%.*s", msg.length, msg.ptr); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/lazy2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module tangotests.lazy2; + +extern(C) int printf(char*, ...); + +void main() +{ + lazy1("hello\n"); +} + +void lazy1(lazy char[] str) +{ + lazy2(str); +} + +void lazy2(lazy char[] msg) +{ + printf("%.*s", msg.length, msg.ptr); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/loops1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module tangotests.loops1; + +void main() +{ + size_t n; + int x; + ushort foo; + for (n=0; n<8; n++,x++) + { + foo >>= 1; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/m.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +void main() +{ + int* e = __errno_location(); + printf("&errno = %p\n", e); + printf("errno = %d\n", *e); +} + +extern(C): +version(darwin) { + int* __error(); + alias __error __errno_location; +} else version (Windows) { + int* strerror(); + alias strerror __errno_location; +} else { + int* __errno_location(); +} +int printf(char*,...);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/mainargs1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module mainargs1; + +extern(C) int printf(char*,...); + +void main(char[][] args) +{ + foreach(v; args) + { + printf("%.*s\n", v.length, v.ptr); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/mainvoidreturn.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +void foo() +{} + +void main() +{ + return foo(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/marray1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +module tangotest.marray1; + +void main() +{ + int[][] arr; + int[] a = [1,2]; + int[] b = [6,7,8,9]; + arr ~= a; + arr ~= b; + assert(a.length == 2); + assert(b.length == 4); + assert(arr.length == 2); + assert(arr[0][0] == 1); + assert(arr[0][1] == 2); + assert(arr[1][0] == 6); + assert(arr[1][1] == 7); + assert(arr[1][2] == 8); + assert(arr[1][3] == 9); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/marray2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module tangotests.marray2; + +void main() +{ + int[][] ma = new int[][](2,4); + assert(ma.length == 2); + assert(ma[0].length == 4); + assert(ma[1].length == 4); + ma[0][3] = 32; + ma[1][2] = 123; + ma[0][0] = 55; + assert(ma[0][3] == 32); + assert(ma[1][2] == 123); + assert(ma[0][0] == 55); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/marray3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,23 @@ +module tangotests.marray3; + +void main() +{ + int[][][] ma = new int[][][](2,4,3); + assert(ma.length == 2); + assert(ma[0].length == 4); + assert(ma[0][0].length == 3); + assert(ma[0][1].length == 3); + assert(ma[0][2].length == 3); + assert(ma[0][3].length == 3); + assert(ma[1].length == 4); + assert(ma[1][0].length == 3); + assert(ma[1][1].length == 3); + assert(ma[1][2].length == 3); + assert(ma[1][3].length == 3); + ma[0][3][0] = 32; + ma[1][2][1] = 123; + ma[0][0][2] = 55; + assert(ma[0][3][0] == 32); + assert(ma[1][2][1] == 123); + assert(ma[0][0][2] == 55); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/mem2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module tangotests.mem2; + +void main() +{ + int* ip = new int; + assert(*ip == 0); + *ip = 4; + assert(*ip == 4); + delete ip; + assert(ip is null); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/mem3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module tangotests.mem3; + +void main() +{ + int[] arr; + arr ~= [1,2,3]; + assert(arr[0] == 1); + assert(arr[1] == 2); + assert(arr[2] == 3); + delete arr; + assert(arr is null); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/mem5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,24 @@ +module tangotests.mem5; + +class SC +{ + int* ip; + this() + { + ip = new int; + } + ~this() + { + delete ip; + } + void check() + { + assert(ip !is null); + } +} + +void main() +{ + scope sc = new SC; + sc.check(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/mem6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module tangotests.mem6; + +extern(C) int printf(char*,...); + +int main(){ + int[] index; + char[] value; + + foreach(int i, char c; "_\U00012345-"){ + printf("str[%d] = %d\n", i , cast(int)c); + index ~= i; + //value ~= c; + } + printf("done\n"); + + return 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/memory1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module memory1; + +extern(C) int printf(char*,...); + +void main() +{ + auto a = new int[16]; + {printf("array.length = %u\n", a.length);} + {a.length = a.length + 1;} + {printf("array.length = %u\n", a.length);} + {assert(a.length == 17);} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/missingti.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +class MyClass +{ +} + +void main() +{ + MyClass[] l; + l.sort; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/moduleinfo1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,33 @@ +module moduleinfo1; + +static this() +{ +} + +static this() +{ +} + +static ~this() +{ +} + +static ~this() +{ +} + +unittest +{ +} + +class C +{ +} + +class D : C +{ +} + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/moduleinfo2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module moduleinfo2; + +extern(C) int printf(char*, ...); + +void main() +{ + printf("listing modules:\n"); + foreach(m; ModuleInfo) + { + printf(" %.*s\n", m.name.length, m.name.ptr); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/multiarr1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,21 @@ +module multiarr1; + +void main() +{ + int[16][16] a; + assert(a[0][0] == 0); + assert(a[0][1] == 0); + assert(a[0][2] == 0); + assert(a[0][3] == 0); + assert(a[10][13] == 0); + assert(a[15][15] == 0); + a[10][13] = 42; + assert(a[0][0] == 0); + assert(a[10][13] == 42); + assert(a[15][15] == 0); + { + int* l = cast(int*)a; + l += 10*16+13; + assert(*l == 42); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/multiarr2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +module multiarr2; + +void main() +{ + static float[1][2][3] arr; + assert(arr[2][1][0] !<>= float.nan); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/multiarr3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module multiarr3; + +void main() +{ + static int[2][2] arr = [[1,2],[3,4]]; + assert(arr[0][0] == 1); + assert(arr[0][1] == 2); + assert(arr[1][0] == 3); + assert(arr[1][1] == 4); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/multiarr4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +module multiarr4; +extern(C) int printf(char*, ...); + +void main() +{ + char[][] a; + a.length = 2; + a[0] = "hello"; + a[1] = "world"; + foreach(v;a) + { + printf("%.*s\n", v.length, v.ptr); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/mutablearrayinit.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +void main() +{ + static int[] b = [1, 2]; + b[0] = 2; + + typedef int[] ia = [1,2]; + static ia a; + a[0] = 5; +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/n.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +struct Structure +{ + static void static_method() + { + } + + void method() + { + } +} + +void main() +{ + //Structure.static_method(); + + Structure s; + s.method(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/naked_asm1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,30 @@ +extern(C) int printf(char*, ...); + +void main() +{ + int i = func(); + printf("%d\n", i); + assert(i == 42); +} + +int func() +{ + version (D_InlineAsm_X86) + { + asm + { + naked; + mov EAX, 42; + ret; + } + } + else version(D_InlineAsm_X86_64) + { + asm + { + naked; + movq RAX, 42; + ret; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/naked_asm2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,30 @@ +int foo() +{ + static size_t fourty2 = 42; + version(X86) + asm + { + naked; + mov EAX, fourty2; + ret; + } + else version (X86_64) + { + asm + { + naked; + movq RAX,fourty2; + ret; + } + } + else static assert(0, "todo"); +} + +void main() +{ + int i = foo(); + printf("i == %d\n", i); + assert(i == 42); +} + +extern(C) int printf(char*, ...);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/naked_asm3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,28 @@ +int foo() +{ + enum { fourty2 = 42 } + version(X86) + asm + { + naked; + mov EAX, fourty2; + ret; + } + else version(X86_64) + asm + { + naked; + mov EAX, fourty2; + ret; + } + else static assert(0, "todo"); +} + +void main() +{ + int i = foo(); + printf("i == %d\n", i); + assert(i == 42); +} + +extern(C) int printf(char*, ...);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/naked_asm4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,25 @@ +void foo() +{ + version(X86) + asm + { + naked; + jmp pass; + hlt; +pass: ret; + } + else version(X86_64) + asm + { + naked; + jmp pass; + hlt; +pass: ret; + } + else static assert(0, "todo"); +} + +void main() +{ + foo(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/naked_asm5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,34 @@ +int foo(int op)(int a, int b) +{ + version(X86) + { + const OP = (op == '+') ? "add" : "sub"; + version (Windows) + { + asm { naked; } + mixin("asm{push EBP;mov EBP,ESP;sub ESP,8;mov ECX,[EBP+8];"~OP~" EAX, ECX;add ESP,8;pop EBP;}"); + asm { ret; } + } else + { + asm { naked; } + mixin("asm{"~OP~" EAX, [ESP+4];}"); + asm { ret 4; } + } + } + else version(X86_64) + { + const OP = (op == '+') ? "add" : "sub"; + asm { naked; } + mixin("asm{"~OP~" ESI,EDI; mov EAX, ESI;}"); + asm { ret; } + } + else static assert(0, "todo"); +} + +void main() +{ + int i = foo!('+')(2, 4); + assert(i == 6); + i = foo!('-')(2, 4); + assert(i == 2); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/naked_asm6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,20 @@ +extern(C) int printf(char*, ...); + +ulong retval() { + version (X86) + asm { naked; mov EAX, 0xff; mov EDX, 0xaa; ret; } + else version (X86_64) + asm { naked; mov RAX, 0xaa000000ff; ret; } +} + +ulong retval2() { + return (cast(ulong)0xaa << 32) | 0xff; +} + +void main() { + auto a = retval(); + auto b = retval2(); + printf("%llu\n%llu\n", retval(), retval2()); + assert(a == 0xaa000000ff); + assert(a == b); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/neg.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module neg; + +void main() +{ + int i = 32; + long l = 55; + float f = 23; + double d = 4; + assert(-i == -32); + assert(-l == -55); + assert(-f == -23); + assert(-d == -4); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module nested1; + +void func(int i) +{ + (){ + assert(i == 3); + }(); +} + +void main() +{ + func(3); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested10.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,22 @@ +module nested10; + +extern(C) int printf(char*, ...); + +void main() +{ + int j = 3; + void F() + { + int i = j; + printf("F: i = %d, j = %d\n", i, j); + void G() + { + printf("G: i = %d, j = %d\n", i, j); + j += i; + } + G(); + } + F(); + printf("6 = %d\n", j); + assert(j == 6); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested11.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,44 @@ +module nested11; + +extern(C) int printf(char*, ...); + +void main() +{ + int i; + + void f() + { + i++; + + void g() + { + i++; + + void h() + { + printf("i = %d\n", i); + } + + h(); + } + + g(); + } + + f(); + assert(i == 2); + + void foo() + { + i = 42; + } + + void bar() + { + foo(); + } + + bar(); + printf("i = %d\n", i); + assert(i == 42); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested12.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,23 @@ +module nested12; + +extern(C) int printf(char*, ...); + +void main() +{ + func(); +} + +void func() +{ + void a(int i) + { + printf("%d\n", i); + } + + void b() + { + a(42); + } + + b(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested13.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,32 @@ +module mini.nested13; + +extern(C) int printf(char*, ...); + +void main() +{ + int var = 2; + + void exec(void delegate() dg) + { + printf("var = %d\n", var); + dg(); + } + + void foo() + { + printf("var = %d\n", var); + assert(var == 5); + } + + void bar() + { + printf("var = %d\n", var); + var += 3; + exec(&foo); + } + + printf("var = %d\n", var); + exec(&bar); + + return; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested14.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +module mini.nested14; + +extern(C) int printf(char*, ...); + +class C +{ + void foo() + { + void bar() + { + car(); + } + + bar(); + } + + void car() + { + printf("great\n"); + } +} + +void main() +{ + scope c = new C; + c.foo(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested15.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,35 @@ +// $HeadURL: svn://svn.berlios.de/dstress/trunk/run/t/this_13_A.d $ +// $Date: 2006-12-31 20:59:08 +0100 (Sun, 31 Dec 2006) $ +// $Author: thomask $ + +// @author@ Frank Benoit <benoit@tionex.de> +// @date@ 2006-10-09 +// @uri@ http://d.puremagic.com/issues/show_bug.cgi?id=419 +// @desc@ [Issue 419] New: Anonymous classes are not working. + +// added to mini to catch regressions earlier + +module mini.nested15; + +class I { + abstract void get( char[] s ); +} + +class C{ + void init(){ + I i = new class() I { + void get( char[] s ){ + func(); + } + }; + } + void func( ){ } +} + +int main(){ + C c = new C(); + c.init(); + + return 0; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested16.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,31 @@ +module mini.nested16; + +void main() +{ + int idx = 123; + int func(int* idp) + { + void foo() + { + void bar(int* idp) + { + auto c = new class + { + void mem() + { + scope(exit) ++*idp; + } + }; + auto dg = () { + c.mem(); + }; + dg(); + } + bar(idp); + ++*idp; + } + foo(); + return ++*idp; + } + assert(func(&idx) == 126); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested17.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,45 @@ +// $HeadURL: svn://svn.berlios.de/dstress/trunk/run/n/nested_class_03_A.d $ +// $Date: 2005-06-18 09:15:32 +0200 (Sat, 18 Jun 2005) $ +// $Author: thomask $ + +// @author@ John C <johnch_atms@hotmail.com> +// @date@ 2005-06-09 +// @uri@ news:d88vta$vak$1@digitaldaemon.com + +//module dstress.run.n.nested_class_03_A; +module mini.nested17; + +interface Inner{ + int value(); +} + +class Outer{ + int x; + + Inner test(){ + printf("val = %d\n", x); + return new class Inner { + int y; + + this(){ + printf("val = %d\n", x); + y=x; + } + + int value(){ + return y; + } + }; + } +} + +int main(){ + Outer o = new Outer(); + o.x=2; + int val = o.test().value(); + printf("val = %d\n", val); + assert(val == o.x); + return 0; +} + +extern(C) int printf(char*, ...);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested19.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +module mini.nested19; + +void main() +{ + int i = 1; + + class C + { + int j = 2; + void func() + { + int k = 3; + + void foo() + { + i = i+j+k; + } + + foo(); + } + } + + auto c = new C; + c.func(); + + assert(i == 6); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,16 @@ +module nested2; + +void func(ref int i) +{ + delegate { + assert(i == 3); + i++; + }(); +} + +void main() +{ + int i = 3; + func(i); + assert(i == 4); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested20.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +extern(C) int printf(char*, ...); + +void main() +{ + int[] arr = [1]; + foreach(s; arr) + { + void foo() + { + printf("n %d\n", s); + } + + printf("o1 %d\n", s); + foo(); + printf("o2 %d\n", s); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested21.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,16 @@ +module nested21; + +extern(C) int printf(char*, ...); + +void main() { + int i = 42; + int foo() { return i; } + int bar() { + int j = 47; + int baz() { return j; } + return foo() + baz(); + } + auto result = bar(); + printf("%d\n", result); + assert(result == 42 + 47); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module nested3; + +void main() +{ + int i; + void test() + { + i = 3; + } + test(); + assert(i == 3); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,12 @@ +module nested4; + +void func(void delegate() dg) { + auto v = (){ + dg(); + }; +} + +void main() +{ + func({}); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,23 @@ +module nested5; +extern(C) int printf(char*, ...); + +void main() +{ + int i = 42; + + printf("Hello world %d\n", i++); + + class C + { + void func() + { + printf("Hello nested world %d\n", i++); + //i++; + } + } + + auto c = new C; + c.func(); + printf("i = %d\n", i); + assert(i == 44); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,33 @@ +module nested6; +extern(C) int printf(char*, ...); + +void main() +{ + int i = 42; + + printf("main() %d\n", i++); + + class C + { + void func() + { + printf("C.func() %d\n", i++); + + class C2 + { + void func2() + { + printf("C2.func2() %d\n", i++); + } + } + + auto c2 = new C2; + c2.func2(); + } + } + + auto c = new C; + c.func(); + + assert(i == 45); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested6a.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,42 @@ +module nested6a; +extern(C) int printf(char*, ...); + +void main() +{ + int i = 42; + + printf("main() %d\n", i++); + + class C + { + int j; + void func() + { + int k; + printf("C.func() %d\n", i++); + + class C2 + { + int l; + void func2() + { + printf("in C2.func2()\n"); + printf("C2.func2() %d\n", i++); + } + int m; + } + + { + printf("new C2\n"); + auto c2 = new C2; + printf("C2.func2()\n"); + c2.func2(); + } + int n; + } + int o; + } + + auto c = new C; + c.func(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,33 @@ +module nested7; +extern(C) int printf(char*, ...); + +void main() +{ + int i; + i = 52; + printf("i = %d\n", i); + + void func() + { + i++; + + void func2() + { + i++; + + void func3() + { + i++; + } + + func3(); + } + + func2(); + } + + func(); + + printf("i = %d\n", i); + assert(i == 55); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested8.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,31 @@ +module nested8; +extern(C) int printf(char*, ...); + +void main() +{ + int i = 1; + void func() + { + printf("func()\n"); + i++; + void func2() + { + printf(" func2()\n"); + int j = i + 1; + void func3() + { + printf(" func3()\n"); + j++; + printf(" done = %d\n", j); + } + func3(); + i = j; + printf(" done = %d\n", j); + } + func2(); + printf("done\n"); + } + func(); + printf("i == %d\n", i); + assert(i == 4); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nested9.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +module nested9; +extern(C) int printf(char*, ...); + +void main() +{ + int i = 42; + int func() + { + return i + 1; + } + int j = func(); + printf("j = %d\n", j); + assert(j == 43); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nocompile_initoverlap1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +struct Vector { + union { float x; float y; } + const static Vector zero = { x : 0, y : 0 }; +} + +struct HBoxLayout { + Vector padding = Vector.zero; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/nocompile_initoverlap2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +struct S +{ + union + { + float f = 1; + int i = 2; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module mini.norun_debug1; + +void main() +{ + int* ptr = cast(int*) 1; + + // all these should be inspectable + int i = 1; + int j = 2; + long k = 3; + float l = 4.521; + ubyte m = 5; + + *ptr = 0;//cast(int)(i+j+k+l+m); +} + +extern(C) int printf(char*, ...);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug10.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,21 @@ +module mini.norun_debug10; + +struct Vec2 +{ + float x,y; +} + +void main() +{ + Vec2 v2; + char[] str = "hello"; + int i = void; + float f = 3.14; + func(v2, v2, str, i, f); +} + +void func(Vec2 v2, ref Vec2 rv2, char[] str, out int i, ref float f) +{ + int* fail = cast(int*) 1; + *fail = 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug11.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,33 @@ +module mini.norun_debug11; + +class C +{ +} + +class D : C +{ + int i = 42; +} + +class E : D +{ + float fp = 3.14f; +} + +class F : E +{ + F f; +} + +void main() +{ + auto c = new C; + auto d = new D; + auto e = new E; + auto f = new F; + + auto ci = c.classinfo; + + int* fail = cast(int*) 1; + *fail = 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug12.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,24 @@ +module mini.norun_debug12; + +interface I +{ + int foo(); +} + +class C : I +{ + int i = 24; + int foo() + { + return i; + } +} + +void main() +{ + scope c = new C; + I i = c; + + int* fail = cast(int*) 1; + *fail = 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module mini.norun_debug2; + +import tango.stdc.stdlib : rand; + +void main() +{ + size_t iter; + while (iter < 25) + { + if (rand() % 20 == 10) + *cast(int*)1 = 0; + ++iter; + } + assert(0); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module mini.norun_debug3; + +void main() +{ + int i = 42; + int* ip = &i; + + int* fail = cast(int*) 1; + *fail = 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module mini.norun_debug4; + +void main() +{ + char c = 'c'; + wchar wc = 'w'; + dchar dc = 'd'; + + int* fail = cast(int*) 1; + *fail = 32; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module mini.norun_debug5; + +void main() +{ + int i = 32; + real r = 3.1415; + real* p = &r; + func(i,r,p); +} + +void func(int i, real r, real* p) +{ + int* fail = cast(int*) 1; + *fail = 666; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +module mini.norun_debug6; + +void main() +{ + char[] str = "hello world :)"; + + int* fail = cast(int*) 1; + *fail = 32; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +module mini.norun_debug7; + +int gi; + +void main() +{ + int* fail = cast(int*) 1; + *fail = 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug8.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,31 @@ +module mini.norun_debug8; + +struct Str +{ + size_t len; + void* ptr; +} + +struct Foo +{ + long l; + Bar bar; +} + +struct Bar +{ + float x,y,z; + Foo* foo; +} + +void main() +{ + Str str; + Foo foo; + foo.l = 42; + foo.bar.y = 3.1415; + foo.bar.foo = &foo; + + int* fail = cast(int*) 1; + *fail = 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/norun_debug9.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module mini.norun_debug9; + +struct Foo +{ + int a,b,c; + + void func() + { + int* fail = cast(int*) 1; + *fail = 0; + } +} + +void main() +{ + Foo foo = Foo(1,10,73); + foo.func(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/o.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,24 @@ +extern(C) int printf(char*, ...); + +void func() +{ + try + { + printf("try\n"); + return; + } + catch + { + printf("catch\n"); + } + finally + { + printf("finally\n"); + } + return; +} + +void main() +{ + func(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/packed1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,24 @@ +module mini.packed1; + +extern(C) int printf(char*, ...); + +align(1) +struct PackedStruct +{ + ubyte ub; + float f; + long l; + short s; + ubyte ub2; + short s2; +} + +void main() +{ + PackedStruct[2] a = void; + void* begin = a.ptr; + void* end = &a[1]; + ptrdiff_t sz = end - begin; + printf("size = 18 = %u = %u\n", PackedStruct.sizeof, sz); + assert(sz == 18); +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/pointers.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,22 @@ +module pointers; + +struct S +{ + long l; +} + +void main() +{ + int j = 42; + int* p = &j; + + auto t = *p; + *p ^= t; + + *p = ~t; + + S s; + S* sp = &s; + *sp = s; + s = *sp; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/pt.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,30 @@ + +extern(C) int printf(char*, ...); + +int main() +{ + char[16] s = void; + { + char[] sd = s; + { + s[0] = 'a'; + s[1] = 'b'; + s[2] = 'c'; + } + + printf("%p %p\n", s.ptr, sd.ptr); + printf("%c%c%c\n", s[0], s[1], s[2]); + } + + char[16] s1 = void; + char[16] s2 = void; + char[] d1 = s1; + + { + printf("%p\n%p\n%p\n", s1.ptr, s2.ptr, d1.ptr); + } + + int[16] arr; + + return 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/ptrarith.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,35 @@ +extern(C) int printf(char*, ...); + +void main() +{ + printf("Pointer arithmetic test\n"); + int* p; + printf("0x%x\n", p); + assert(p++ is null); + assert(cast(size_t)p == 4); + printf("0x%x\n", p); + p--; + assert(p is null); + printf("0x%x\n", p); + int d = 4; + p+=d; + printf("0x%x\n", p); + assert(cast(size_t)p == 16); + d = 2; + p+=d; + printf("0x%x\n", p); + assert(cast(size_t)p == 0x18); + d = 6; + p-=d; + printf("0x%x\n", p); + assert(p is null); + printf(" SUCCESS\n"); +} + +void fill_byte_array(ubyte* a, size_t n, ubyte v) +{ + auto p = a; + auto end = a+n; + while (p !is end) + *p++ = v; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/ptrcond.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module mini.ptrcond; + +void main() +{ + char[4]* cp; + void* vp = &cp; + assert(cp < vp); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/r.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +extern(C) int printf(char*, ...); + +class C +{ + void dump() + { + printf("C dumped\n"); + } +} + +void heap() +{ + auto c = new C; + c.dump(); +} + +void stack() +{ + scope c = new C; + c.dump(); +} + +void main() +{ + heap(); + stack(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/real1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +module mini.real1; + +extern(C) +{ +real tanl(real x); +int printf(char*, ...); +} + +void main() +{ + real ans = tanl(0.785398163398); + printf("%llf\n", ans); + assert(ans > 0.999 && ans < 1.001); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/s.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,84 @@ +module s; + +interface Inter +{ + void inter(); +} + +interface Inter2 +{ + void inter2(); +} + +interface InterOne : Inter +{ + void interOne(); +} + +abstract class ClassAbstract : InterOne +{ + abstract void inter(); + abstract void interOne(); +} + +class TheClassOne : ClassAbstract +{ + void inter() + { + } + void interOne() + { + } +} + +class TheClassTwo : TheClassOne, Inter2 +{ + long l; + double d; + + void inter2() + { + } +} + +extern(C) int printf(char*, ...); + +void main() +{ + printf("classinfo test\n"); + { + auto c = new TheClassOne; + { + auto ci = c.classinfo; + printf("ci = %.*s\n", ci.name.length, ci.name.ptr); + printf("ci.interfaces.length = %lu\n", ci.interfaces.length); + foreach (i, iface; ci.interfaces) + printf("i[%d] = %.*s\n", i, iface.classinfo.name.length, iface.classinfo.name.ptr); + } + } + { + auto c = new TheClassTwo; + { + auto ci = c.classinfo; + printf("ci = %.*s\n", ci.name.length, ci.name.ptr); + printf("ci.interfaces.length = %lu\n", ci.interfaces.length); + foreach (i, iface; ci.interfaces) + printf("i[%d] = %.*s\n", i, iface.classinfo.name.length, iface.classinfo.name.ptr); + } + InterOne i = c; + { + auto ci = i.classinfo; + printf("ci = %.*s\n", ci.name.length, ci.name.ptr); + } + auto i2 = cast(Inter2)c; + { + auto ci = i2.classinfo; + printf("ci = %.*s\n", ci.name.length, ci.name.ptr); + } + auto o = cast(Object)i2; + { + auto ci = o.classinfo; + printf("ci = %.*s\n", ci.name.length, ci.name.ptr); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/scope1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module scope1; +extern(C) int printf(char*, ...); +void main() +{ + printf("1\n"); + { + scope(exit) printf("2\n"); + } + printf("3\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/scope2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module scope2; +extern(C) int printf(char*, ...); +void main() +{ + scope(exit) printf("exit\n"); + scope(failure) printf("failure\n"); + scope(success) printf("success\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/scope3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module scope3; +extern(C) int printf(char*, ...); +void main() +{ + int i; + while (i < 10) { + scope(success) i++; + } + printf("%d\n", i); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/scope4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module scope4; +int main() +{ + int i; + try + { + return i; + } + finally + { + //i = 1; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/scope5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +module scope5; + +int i; + +void func(int a, int b) +{ + i = 0; + { + scope(exit) i++; + if (a) { + scope(exit) i++; + if (b) return; + i++; + } + } + i++; +} + +void main() +{ + func(0,0); + assert(i == 2); + func(1,1); + assert(i == 2); + func(1,0); + assert(i == 4); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/sextzext.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,68 @@ +module mini.sextzext; + +void main() +{ + byte sb = sextreturn1(); + short ss = sextreturn2(); + assert(ss == -2); + assert(sb == -2); + assert(sextparam1(-42) == -42); + assert(sextparam2(-42) == -42); + + ubyte ub = zextreturn1(); + ushort us = zextreturn2(); + assert(ub == 2); + assert(us == 2); + assert(zextparam1(42) == 42); + assert(zextparam2(42) == 42); + + assert(getchar() == 'a'); + assert(passchar('z') == 'z'); + +} + +byte sextreturn1() +{ + return -2; +} +short sextreturn2() +{ + return -2; +} + +ubyte zextreturn1() +{ + return 2; +} +ushort zextreturn2() +{ + return 2; +} + +byte sextparam1(byte b) +{ + return b; +} +short sextparam2(short s) +{ + return s; +} + +ubyte zextparam1(ubyte b) +{ + return b; +} +ushort zextparam2(ushort s) +{ + return s; +} + +char getchar() +{ + return 'a'; +} + +char passchar(char ch) +{ + return ch; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/sieve.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,33 @@ +/* Eratosthenes Sieve prime number calculation. */ + +extern(C) int printf(char*, ...); + +bool flags[8191]; + +int main() +{ int i, prime, k, count, iter; + + printf("10 iterations\n"); + for (iter = 1; + iter <= 10; + iter++) + { + count = 0; + flags[] = true; + for (i = 0; i < flags.length; i++) + { if (flags[i]) + { + prime = i + i + 3; + k = i + prime; + while (k < flags.length) + { + flags[k] = false; + k += prime; + } + count += 1; + } + } + } + printf("%d primes\n", count); + return 0; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/slices.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,34 @@ +module slices; + +void main() +{ + //char[] a = "hello world"; + //char[5] b = a[0..5]; + + //char* cp = a.ptr; + //char[] c = cp[0..1]; +} + +char[] first5(char[] str) +{ + char* p = str.ptr; + return p[0..5]; +} + +int[] one() +{ + static int i; + return (&i)[0..1]; +} + +void[] init() +{ +static char c; +return (&c)[0 .. 1]; +} + +void[] init2() + { static char c; + + return (cast(char *)&c)[0 .. 1]; + } \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/slices2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,5 @@ +void main() +{ + int[10] arr = void; + int[]* ptr = &arr[1..3]; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/sqrts.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,19 @@ +module sqrts; + +version(Tango) +{ + import tango.stdc.math; +} +else +{ + import std.math; +} + +double sqrt(double d) +{ + return tango.stdc.math.sqrt(d); +} + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/static_ctor.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,16 @@ +extern(C) int printf(char*, ...); + +static this() +{ + printf("static this\n"); +} + +static ~this() +{ + printf("static ~this\n"); +} + +void main() +{ + printf("main\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/staticarrays.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,78 @@ +extern(C) int printf(char*, ...); + +void numbers() +{ + bool[8] bools; + char[8] chars; + byte[8] bytes; + short[8] shorts; + int[8] ints; + long[8] longs; + float[8] floats; + double[8] doubles; + real[8] reals; + { + bools[7] = true; + floats[7] = 3.14159265; + { + printf("bools[0] = %d, bools[7] = %d\n", bools[0], bools[7]); + printf("floats[0] = %f, floats[7] = %f\n", floats[0], floats[7]); + } + } +} + +struct S +{ + int i = 42; + void print() + { + printf("S.i = %d\n", i); + } +} + +class C +{ + int i; + this() + { + i = 3; + } + void print() + { + printf("C.i = %d\n", i); + } +} + +void refs() +{ + void*[5] voids; + S*[5] structs; + C[5] classes; + + { + voids[0] = cast(void*)0xA; + printf("void* = %p\n", voids[0]); + } + { + structs[0] = new S; + structs[0].print(); + delete structs[0]; + } + { + classes[0] = new C; + classes[0].print(); + delete classes[0]; + } +} + +void vals() +{ + S[5] structs; +} + +void main() +{ + numbers(); + refs(); + vals(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/staticvars.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module staticvars; + +int func() +{ + static int i; + return i++; +} + +void main() +{ + assert(func() == 0); + assert(func() == 1); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/strings1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module strings1; +extern(C) int printf(char*, ...); +void f(char[11] buffer) +{ + printf("%.*s\n", buffer.length, buffer.ptr); +} + +void main() +{ + char[11] buffer; + char[] hello = "hello world"; + {buffer[] = hello[];} + {f(buffer);} + {f("eleven char");} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/strings2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,5 @@ +void main() +{ + char[] s = ""; + assert(s); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structinit.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,25 @@ +module structinit; + +import structinit2; + +struct S +{ + uint ui; + float f; + long l; + real r; +} + +S adef; + +S a = { 1, 2.0f }; +S b = { f:2.0f, l:42 }; + +Imp imp; + +void main() +{ + //assert(a == S.init); + //assert(b == S(0,3.14f,0,real.init)); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structinit2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,16 @@ +module structinit2; + +struct Imp +{ + int i; + long l; + float f; +} + +void main() +{ + Imp i; + assert(i.i == 0); + assert(i.l == 0L); + assert(i.f !<>= 0.0f); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structinit3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +struct S { + int a; int b; int c; int d = 7; +} +void test(int i) { + S s = { 1, i }; // q.a = 1, q.b = i, q.c = 0, q.d = 7 + assert(s.a == 1); + assert(s.b == i); + assert(s.c == 0); // line 8 + assert(s.d == 7); +} +void main() { + test(42); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structinit4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +// testcase from bug #199 + +struct Color { + uint c; + +} + +struct Vertex { + Color c; +} + +void main() { + Color c = {0xffffffff}; + + auto v = Vertex(c); + + assert(v.c.c == 0xffffffff); // fails in LDC +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structinit5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +struct Vertex { + uint[1] c; +} + +void main() { + uint[1] c = 0xffffffff; + + auto v = Vertex(c); + + assert(v.c[0] == 0xffffffff); // fails in LDC +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structs.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +struct S +{ + int func() + { + return 42; + } +} + +void main() +{ + S s; + int i = s.func(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structs2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module structs2; + +struct S +{ + int i; + char c; + S* s; + char[4] ca; +} + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structs3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,30 @@ +module structs3; + +struct S +{ + char c; + float f; +} + +struct T +{ + S s; + long l; +} + +void main() +{ + T t; + float f = void; + float* fp = void; + {f = t.s.f;} + {t.s.f = 0.0;} + {fp = &t.s.f;} + {*fp = 1.0;} + {assert(t.s.f == 1.0);} + {assert(*(&t.s.f) == 1.0);} + {t.s.c = 'a';} + {assert(t.s.c == 'a');} + {t.l = 64;} + {assert(t.l == 64);} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structs4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,26 @@ +module structs4; + +struct S{ + int a; + T t; +} + +struct T{ + int b; + U u; +} + +struct U{ + int c; +} + +void main() +{ + S s; + s.a = 3; + s.t = T.init; + s.t.b = 4; + s.t.u = U.init; + s.t.u.c = 5; + //{assert(s.t.u.c == 5);} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structs5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,23 @@ +module structs5; + +void main() +{ + {S s = S();} + {T t = T(1);} + {U u = U();} +} + +struct S +{ +} + +struct T +{ + int i; +} + +struct U +{ + S s; + long l; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structs6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module structs6; + +struct S +{ + float f; +} + +void func(S s) +{ +} + +void main() +{ + func(S()); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structs7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +module structs7; + +struct S +{ + int i; + long l; +} + +void main() +{ + S s = void; + int i = s.i; + long l = s.l; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/structs8.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,54 @@ +module test.structs8; + +struct S +{ + int a,b; +} + +void main() +{ + S a = S(1,2); + S b = S(2,3); + S c = S(3,4); + S d = S(2,3); + + assert(a == a); + assert(a != b); + assert(a != c); + assert(a != d); + + assert(b != a); + assert(b == b); + assert(b != c); + assert(b == d); + + assert(c != a); + assert(c != b); + assert(c == c); + assert(c != d); + + assert(d != a); + assert(d == b); + assert(d != c); + assert(d == d); + + assert(a is a); + assert(a !is b); + assert(a !is c); + assert(a !is d); + + assert(b !is a); + assert(b is b); + assert(b !is c); + assert(b is d); + + assert(c !is a); + assert(c !is b); + assert(c is c); + assert(c !is d); + + assert(d !is a); + assert(d is b); + assert(d !is c); + assert(d is d); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/switch1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module switch1; + +void main() +{ + int i = 2; + int r; + switch (i) + { + case 1: r+=1; break; + case 2: r-=2; + case 3: r=3; break; + default: r=-1; + } + assert(r == 3); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/switch2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module switch2; +extern(C) int printf(char*, ...); + +void main() +{ + int i = 2; + switch(i) + { + case 0: assert(0); + case 1,2: printf("hello world\n"); break; + default: assert(0); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/switch3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,25 @@ +module switch3; +extern(C) int printf(char*, ...); + +void main() +{ + char[] str = "hello"; + int i; + switch(str) + { + case "world": + i = 1; + assert(0); + case "hello": + i = 2; + break; + case "a","b","c": + i = 3; + assert(0); + default: + i = 4; + assert(0); + } + assert(i == 2); + printf("SUCCESS\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/switch4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +module tangotests.switch1; + +void main() +{ + switch(0) + { + default: + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/switch5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module tangotests.switch2; + +void main() +{ + int i=0; + switch(i) + { + case 0: + return; + case 1: + return; + default: + assert(0); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/switch6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,21 @@ +module tangotests.switch3; + +void main() +{ + int i = 2; + + switch(i) + { + case 0,1,4,5,6,7,8,9: + assert(0); + case 2: + return; + case 3: + { + i++; + case 11: + i++; + } + return; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/sync1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module sync1; + +void main() +{ + int i; + int j; + synchronized j = i; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/sync1_1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,7 @@ +module tangotests.sync1; + +void main() +{ + size_t id; + synchronized id = 4; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/sync2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module tangotests.sync2; + +class Lock +{ +} + +const Lock lock; + +static this() +{ + lock = new Lock; +} + +void main() +{ + size_t id; + synchronized(lock) id = 2; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/sync3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module tangotests.sync3; + +void main() +{ + int i = foo(); +} + +int foo() +{ + int res; + synchronized + { + scope(exit) res--; + res++; + return res; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/t.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,34 @@ +interface MyInterface +{ + int func(); +} + +class MyClass : MyInterface +{ + int var; + int func() + { + return var; + } +} + +void func1(MyInterface i) +{ + int delegate() dg = &i.func; + func2(dg); +} + +extern(C) int printf(char*, ...); + +void func2(int delegate() dg) +{ + int i = dg(); + printf("%d\n", i); +} + +void main() +{ + auto c = new MyClass; + c.var = 42; + func1(c); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/terms.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,45 @@ +module terms; + +void f() +{ + int i = 42; + if (i > 25) + return; + if (i < 25) { + return; + } + + if (i > 100) + return; + else + return; + + if (i < 1000) { + return; + } + else { + return; + } +} + +void main() +{ + int i = 42; + if (i > 25) + return; + if (i < 25) { + return; + } + + if (i > 100) + return; + else + return; + + if (i < 1000) { + return; + } + else { + return; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/throw1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +module throw1; + +extern(C) int rand(); + +class C +{ +} + +void func(bool b) +{ + if (b) + throw new C; +} + +int main() +{ + bool b = true; + try + { + func(b); + } + catch(Object) + { + return 0; + } + return 1; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/tryfinally1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +void main() +{ + try + { + } + finally + { + debug {} // the debug statement body can be anything + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/tuple1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module tuple1; + +template Tuple(T...) { + alias T Tuple; +} + +struct S +{ + int i; + long l; +} + +void main() +{ + S s = S(Tuple!(1,2L)); + assert(s.i == 1); + assert(s.l == 2); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/tuple_and_vararg.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +// Based on dstress.run.t.tuple_15_A; + +module tuple_and_vararg; + +template TypeTuple(TList...){ + alias TList TypeTuple; +} + +void main(){ + auto y = function(TypeTuple!(uint,uint) ab, ...){}; + y(1, 2); + y(1, 2, "foo", 3.0); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/tuplestruct.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +struct V(T...) { + T v; +} + +alias V!(float, int) MyV; + +void main() +{ + assert(MyV.sizeof == float.sizeof + int.sizeof); + auto f = 3.75f; + auto v = MyV(f, 3); + assert(v.v[0] == 3.75f); + assert(v.v[1] == 3); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/tupleval.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,30 @@ +module foo; + +template ParameterTupleOf( Fn ) +{ + static if( is( Fn Params == function ) ) + alias Params ParameterTupleOf; + else static if( is( Fn Params == delegate ) ) + alias ParameterTupleOf!(Params) ParameterTupleOf; + else static if( is( Fn Params == Params* ) ) + alias ParameterTupleOf!(Params) ParameterTupleOf; + else + static assert( false, "Argument has no parameters." ); +} + +struct S +{ + int opApply(T)(T dg) + { + alias ParameterTupleOf!(T) U; + U u; + u[0] = 1; + u[1] = 2; + return 0; + } +} + +void main() +{ + foreach(int x, int y; S()){} +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module typeinfo; +extern(C) int printf(char*, ...); + +void main() +{ + auto ti = typeid(int); + char[] str = ti.toString(); + printf("%.*s\n", str.length, str.ptr); + assert(str == "int"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo10.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,67 @@ +module typeinfo10; + +struct S +{ + long l; + float f; + void* vp; + + hash_t toHash() + { + return l + cast(size_t)f; + } + + int opEquals(S s) + { + return (s.l == l) && (s.f == f); + } + + int opCmp(S a) + { + if (l == a.l) { + return (f < a.f) ? -1 : (f > a.f) ? 1 : 0; + } + return (l < a.l) ? -1 : 1; + } + + char[] toString() + { + return "S instance"; + } +} + +void main() +{ + S s=S(-1, 0); + S t=S(-1, 1); + S u=S(11,-1); + S v=S(12,13); + + { + assert(s == s); + assert(s != t); + assert(s != v); + assert(s < t); + assert(u > s); + assert(v > u); + } + + { + auto ti = typeid(S); + assert(ti.getHash(&s) == s.toHash()); + assert(ti.equals(&s,&s)); + assert(!ti.equals(&s,&t)); + assert(!ti.equals(&s,&v)); + assert(ti.compare(&s,&s) == 0); + assert(ti.compare(&s,&t) < 0); + assert(ti.compare(&u,&s) > 0); + assert(ti.compare(&v,&u) > 0); + { + auto tis = cast(TypeInfo_Struct)ti; + char[] delegate() structToString; + structToString.ptr = &s; + structToString.funcptr = tis.xtoString; + assert(structToString() == s.toString()); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo11.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module typeinfo11; + +void main() +{ + int[4] a; + TypeInfo ti; + ti = typeid(typeof(a)); + assert(ti.next() is typeid(int)); + assert(ti.tsize() == 16); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo12.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,9 @@ +module typeinfo12; + +class C +{ +} + +void main() +{ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo13.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module typeinfo13; + +void main() +{ + float[long] aa; + auto ti = typeid(typeof(aa)); + assert(ti.toString() == "float[long]"); + assert(ti.next() is typeid(float)); + assert(ti.tsize() == size_t.sizeof); + auto aati = cast(TypeInfo_AssociativeArray)ti; + assert(aati.value is typeid(float)); + assert(aati.key is typeid(long)); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +module typeinfo2; + +void main() +{ + auto ti = typeid(float); + float f = 2.5; + hash_t fh = ti.getHash(&f); + assert(ti.next is null); + float g = 4.0; + ti.swap(&f,&g); + assert(f == 4.0 && g == 2.5); + assert(fh == *cast(uint*)(&g)); + assert(!ti.flags); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +module typeinfo3; + +typedef int int_t; + +void main() +{ + /*int_t i; + auto ti = typeid(typeof(i)); + printf("%s\n",ti.toString.ptr); + assert(ti.toString() == "typeinfo3.int_t"); + assert(ti.next !is null); + assert(ti.next.toString() == "int"); + assert(ti.init is null);*/ +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module typeinfo4; + +void main() +{ + auto ti = typeid(void*); + assert(ti.toString() == "void*"); + assert(ti.tsize() == size_t.sizeof); + void* a = null; + void* b = a + 1; + assert(ti.compare(&a,&b) < 0); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +module typeinfo5; + +void main() +{ + enum E : uint { + A,B,C + } + auto ti = typeid(E); + assert(ti.next() is typeid(uint)); + assert(ti.init is null); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,8 @@ +module typeinfo6; + +void main() +{ + auto ti = typeid(int[]); + assert(ti.toString() == "int[]"); + assert(ti.next() is typeid(int)); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +module typeinfo7; +extern(C) int printf(char*, ...); +int func(long) +{ + return 0; +} + +void main() +{ + auto ti = typeid(typeof(func)); + auto s = ti.toString; + printf("%.*s\n", s.length, s.ptr); + assert(s == "int()"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo8.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module typeinfo8; +extern(C) int printf(char*, ...); +struct S +{ + void func() + { + } +} + +void main() +{ + S a; + auto ti = typeid(typeof(&a.func)); + auto s = ti.toString; + printf("%.*s\n", s.length, s.ptr); + assert(s == "void delegate()"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/typeinfo9.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module typeinfo9; + +typedef int int_t = 42; + +void main() +{ + auto i = typeid(int_t).init; + assert(i.length == int_t.sizeof); + assert(*cast(int_t*)i.ptr == 42); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/union1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,14 @@ +module union1; + +union U +{ + float f; + int i; +} + +void main() +{ + float f = 2; + U u = U(f); + assert(u.i == *cast(int*)&f); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/union2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module union2; + +union U +{ + float f; + long l; +} + +U u; + +void main() +{ + assert(u.f !<>= 0); + { + uint* p = 1 + cast(uint*)&u; + {assert(*p == 0);} + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/union3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,13 @@ +module union3; + +union vec3 +{ + struct { float x,y,z; } + float[3] xyz; +} + +void main() +{ + vec3 v; + assert(&v.y is &v.xyz[1]); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/union4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module union4; + +union U { + struct { float x,y,z; } + float[3] xyz; +} + +void main() { + const float[3] a = [1f,2,3]; + U u = U(1,2,3); + assert(u.xyz == a); + assert(u.x == 1); + assert(u.y == 2); + assert(u.z == 3); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/union5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,36 @@ +module union5; + +union S +{ + T t; + U u; + uint i; + struct { + ushort sl,sh; + } +} + +struct T +{ + int i; +} + +struct U +{ + float f; +} + +void main() +{ + S s; + assert(s.t.i == 0); + assert(s.u.f == 0); + s.t.i = -1; + assert(s.i == 0xFFFF_FFFF); + float f = 3.1415; + s.u.f = f; + uint pi = *cast(uint*)&f; + assert(s.i == pi); + assert(s.sl == (pi&0xFFFF)); + assert(s.sh == (pi>>>16)); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/union6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,20 @@ +module union6; + +struct S +{ + byte a; + byte b; +} +union U +{ + byte a; + byte b; + S c; +} + +void main() +{ + U u; + auto a = u.c.b; + //auto c = u.s.l; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/union7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,47 @@ +module union7; + +struct Union +{ + union { + double g; + struct { + short s1,s2,s3,s4; + } + } + union { + float f; + long l; + } +} + +Union a = { f:4f }; +Union b = { 3.0, f:2 }; +Union c = { l:42, g:2.0 }; +Union d = { s2:3 }; +Union e = { s1:3, s4:4, l:5 }; + +void main() +{ + assert(a.f == 4f); + assert(a.g !<>= 0.0); + assert((a.l>>>32) == 0); + + assert(b.g == 3.0); + assert(b.f == 2f); + + assert(c.l == 42); + assert(c.g == 2.0); + + assert(d.s1 == 0); + assert(d.s2 == 3); + assert(d.s3 == 0); + assert(d.s4 == 0); + {assert(d.f !<>= 0f);} + {} + assert(e.s1 == 3); + assert(e.s2 == 0); + assert(e.s3 == 0); + {assert(e.s4 == 4);} + {} + assert(e.l == 5); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/unittest1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,10 @@ +module unittest1; + +void main() +{ +} + +unittest +{ + printf("hello\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/unrolled.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,15 @@ +module unrolled; + +extern(C) int printf(char*, ...); + +void test(T...)(T t) { + foreach (value; t) { + printf("%d\n", value); + if (value == 2) + break; + } +} + +void main() { + test(1,4,3); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/v2d.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,32 @@ +extern(C) int printf(char*, ...); + +struct V2D(T) +{ + T x,y; + + T dot(ref V2D v) + { + return x*v.x + y*v.y; + } + + V2D opAdd(ref V2D v) + { + return V2D(x+v.x, y+v.y); + } +} + +alias V2D!(float) V2Df; + +void main() +{ + printf("V2D test\n"); + auto up = V2Df(0.0f, 1.0f); + auto right = V2Df(1.0f, 0.0f); + assert(up.dot(right) == 0.0f); + auto upright = up + right; + assert(upright.x == 1.0f && upright.y == 1.0f); + auto copy = upright; + copy.x++; + assert(copy.x > upright.x); + printf(" SUCCESS\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/vararg1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,27 @@ +module vararg1; + +version(Tango) +{ + import tango.core.Vararg; +} +else +{ + import std.c.stdarg; +} + +extern(C) int add(int n, ...) +{ + va_list ap=void; + va_start(ap, n); + int r; + for (int i=0; i<n; i++) + r += va_arg!(int)(ap); + va_end(ap); + return r; +} + +void main() +{ + int i = add(4, 1,2,3,4); + assert(i == 10); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/vararg2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module vararg2; + +void func(...) +{ + assert(_arguments.length == 2); + assert(_arguments[0] is typeid(int)); + int a = *cast(int*)_argptr; + _argptr += size_t.sizeof; + assert(_arguments[1] is typeid(int)); + a += *cast(int*)_argptr; + _argptr += int.sizeof; + assert(a == 3); +} + +void main() +{ + func(1,2); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/vararg3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,26 @@ +module vararg3; + +version(Tango) +{ + import tango.core.Vararg; +} +else +{ + import std.c.stdarg; +} + +void func(...) +{ + assert(_arguments.length == 3); + assert(_arguments[0] is typeid(int)); + assert(_arguments[1] is typeid(float)); + assert(_arguments[2] is typeid(long)); + assert(va_arg!(int)(_argptr) == 4); + assert(va_arg!(float)(_argptr) == 2.5f); + assert(va_arg!(long)(_argptr) == 42L); +} + +void main() +{ + func(4, 2.5f, 42L); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/vararg4.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,45 @@ +module vararg4; + +version(Tango) +{ + import tango.core.Vararg; +} +else +{ + import std.c.stdarg; +} +extern(C) int printf(char*, ...); + +void vafunc(...) +{ + foreach(i,v; _arguments) { + if (typeid(byte) == v) { + printf("byte(%d)\n", va_arg!(byte)(_argptr)); + } + else if (typeid(short) == v) { + printf("short(%d)\n", va_arg!(short)(_argptr)); + } + else if (typeid(int) == v) { + printf("int(%d)\n", va_arg!(int)(_argptr)); + } + else if (typeid(long) == v) { + printf("long(%ld)\n", va_arg!(long)(_argptr)); + } + else if (typeid(float) == v) { + printf("float(%f)\n", va_arg!(float)(_argptr)); + } + else if (typeid(double) == v) { + printf("double(%f)\n", va_arg!(double)(_argptr)); + } + else if (typeid(real) == v) { + printf("real(%f)\n", va_arg!(real)(_argptr)); + } + else + assert(0, "unsupported type"); + } +} + +void main() +{ + vafunc(byte.max,short.max,1,2,3,4L,5.0f,6.0,cast(real)7); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/vararg5.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,22 @@ +module vararg5; + +version(Tango) +{ + import tango.core.Vararg; +} +else +{ + import std.c.stdarg; +} + +extern(C) int printf(char*, ...); +void func(...) +{ + char[] str = va_arg!(char[])(_argptr); + {printf("%.*s\n", str.length, str.ptr);} +} +void main() +{ + char[] str = "hello"; + func(str); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/vararg6.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,249 @@ +// tries to implement a fairly complete variadic print function +module tangotests.vararg6; + +extern(C) int printf(char*, ...); + +struct User +{ + char[] name; + char[] nick; + uint age; + + char[] toString() + { + return nick ~ "(" ~ name ~ ")"; + } +} + +struct Infidel +{ + char[] whocares; +} + +class Obj +{ + private char[] ty; + + this(char[] t) + { + ty = t; + } + + char[] toString() + { + return "Obj(" ~ ty ~ ")"; + } +} + + struct TLA + { + char[3] acronym; + + char[] toString() + { + return acronym; + } +} + +void main() +{ + User user = User("Bob Doe", "bd", 47); + char[] str = user.toString(); + printf("Direct call:\n%.*s\nBy typeinfo:\n", str.length, str.ptr); + print(user, '\n'); + + print("Without toString:\n"); + Infidel inf = Infidel("not me"); + print(inf, '\n'); + + print("Character arrays:\n"); + print("hello world\n"); + + print("Signed integers:\n"); + print(cast(byte)byte.max,' ',cast(short)short.max,' ',cast(int)int.max,' ',cast(long)long.max,'\n'); + + print("Unsigned integers:\n"); + print(cast(ubyte)ubyte.max,' ',cast(ushort)ushort.max,' ',cast(uint)uint.max,' ',cast(ulong)ulong.max,'\n'); + + print("Floating point:\n"); + print(cast(float)1.273f, ' ', cast(double)3.412367, ' ', cast(real)142.96731112, '\n'); + + print("Arrays:\n"); + int[] ia1 = [1,2,3,4,5,6,7,8,9]; + print(ia1, '\n'); + float[] fa1 = [0.1f, 0.15f, 0.2f, 0.25f, 0.3f]; + print(fa1, '\n'); + + print("Pointers:\n"); + print(&user,'\n'); + print(&inf,'\n'); + print(&ia1,'\n'); + print(&fa1,'\n'); + + print("Static arrays:\n"); + int[5] isa1 = [1,2,4,8,16]; + print(isa1,'\n'); + + print("Classes:\n"); + Obj o = new Obj("foo"); + print(o, '\n'); + + print("Mixed:\n"); + print(123, ' ', 42.536f, " foobar ", ia1, ' ', user, '\n'); + print(42, ' ', cast(byte)12, ' ', user, ' ', cast(short)1445, " foo\n"); + + print("International:\n"); + print('æ','ø','å','\n'); + print('Æ','Ø','Å','\n'); + print("rød grød med fløde\n"); + print("Heiße\n"); + + print("TLAs:\n"); + TLA tla1 = TLA("FBI"); + TLA tla2 = TLA("CIA"); + TLA tla3 = TLA("TLA"); + print(tla1); + print(tla2); + print(tla3, '\n'); + print(tla1, tla2, tla3, '\n'); + print(TLA("FBI"), TLA("CIA"), TLA("TLA"), '\n'); + + print("Done!\n"); +} + +private void* get_va_arg(TypeInfo ti, ref void* vp) +{ + void* arg = vp; + vp = vp + ( ( ti.tsize + size_t.sizeof - 1 ) & ~( size_t.sizeof - 1 ) ); + return arg; +} + +void print(TypeInfo ti, void* arg) +{ + if (ti == typeid(byte)) + printf("%d", *cast(byte*)arg); + else if (ti == typeid(short)) + printf("%d", *cast(short*)arg); + else if (ti == typeid(int)) + printf("%d", *cast(int*)arg); + else if (ti == typeid(long)) + printf("%lld", *cast(long*)arg); + + else if (ti == typeid(ubyte)) + printf("%u", *cast(ubyte*)arg); + else if (ti == typeid(ushort)) + printf("%u", *cast(ushort*)arg); + else if (ti == typeid(uint)) + printf("%u", *cast(uint*)arg); + else if (ti == typeid(ulong)) + printf("%llu", *cast(ulong*)arg); + + else if (ti == typeid(float)) + printf("%f", *cast(float*)arg); + else if (ti == typeid(double)) + printf("%f", *cast(double*)arg); + else if (ti == typeid(real)) + printf("%llf", *cast(real*)arg); + + else if (ti == typeid(char)) + printf("%c", *cast(char*)arg); + else if (ti == typeid(wchar)) + foreach (char c; (cast(wchar*)arg)[0..1]) + printf("%c", c); + else if (ti == typeid(dchar)) + foreach (char c; (cast(dchar*)arg)[0..1]) + printf("%c", c); + + else if (ti == typeid(char[])) + { + char[] str = *cast(char[]*)arg; + printf("%.*s", str.length, str.ptr); + } + else if (ti == typeid(wchar[])) + { + wchar[] str = *cast(wchar[]*)arg; + printf("%.*s", str.length*2, str.ptr); + } + else if (ti == typeid(dchar[])) + { + dchar[] str = *cast(dchar[]*)arg; + printf("%.*s", str.length*4, str.ptr); + } + + else if (auto pti = cast(TypeInfo_Pointer)ti) + { + printf("%p", *cast(void**)arg); + } + + else if (auto sti = cast(TypeInfo_Struct)ti) + { + if (sti.xtoString !is null) + { + char[] delegate() toString; + toString.ptr = arg; + toString.funcptr = sti.xtoString; + char[] str = toString(); + printf("%.*s", str.length, str.ptr); + } + else + { + char[] str = sti.toString(); + printf("%.*s", str.length, str.ptr); + } + } + + else if (auto ati = cast(TypeInfo_Array)ti) + { + auto tnext = ati.next; + size_t len = *cast(size_t*)arg; + void* ptr = *(cast(void**)arg + 1); + printf("["); + for(auto i=0; i<len; ++i) + { + print(tnext, get_va_arg(tnext, ptr)); + if (i < len-1) + printf(","); + } + printf("]"); + } + + else if (auto cti = cast(TypeInfo_Class)ti) + { + auto o = *cast(Object*)arg; + char[] str = o.toString(); + printf("%.*s", str.length, str.ptr); + } + + // static arrays are converted to dynamic arrays when passed to variadic functions + else if (auto sati = cast(TypeInfo_StaticArray)ti) + { + assert(0, "static arrays not supported"); + } + + else if (auto aati = cast(TypeInfo_AssociativeArray)ti) + { + assert(0, "associative array not supported"); + } + + else + { + char[] str = ti.toString(); + printf("typeinfo: %.*s\n", str.length, str.ptr); + str = ti.classinfo.name; + printf("typeinfo.classinfo: %.*s\n", str.length, str.ptr); + assert(0, "unsupported type ^"); + } +} + +void print(...) +{ + void* argptr = _argptr; + assert(argptr); + + foreach(i,ti; _arguments) + { + void* arg = get_va_arg(ti, argptr); + assert(arg); + print(ti, arg); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/vararg7.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,30 @@ +module tangotests.vararg4; + +extern(C) int printf(char*, ...); + +struct S +{ + int i; +} + +void func(...) +{ + S* sp = cast(S*)_argptr; + assert(sp.i == 42); +} + +void main() +{ + printf("1st:\n"); + { + S s = S(42); + func(s); + } + printf("ok\n"); + + printf("2nd:\n"); + { + func(S(42)); + } + printf("ok\n"); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/virtcall.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,18 @@ +module virtcall; + +extern(C) int printf(char*, ...); + +class C +{ + override char[] toString() + { + return "overridden"; + } +} + +void main() +{ + C c = new C; + auto s = c.toString(); + printf("%.*s\n", s.length, s.ptr); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/virtcall2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,78 @@ +enum { + COMMON, + INPUT, + OUTPUT, + CONDUIT, + OTHER +} + +interface Common +{ int common(); } + +interface Input : Common +{ int input(); } + +interface Output : Common +{ int output(); } + +interface Conduit : Input, Output +{ abstract int conduit(); } + +class Abstract : Conduit +{ + abstract int conduit(); + abstract int output(); + abstract int input(); + int common() { return COMMON; } +} + +interface Other +{ int other(); } + +class Impl : Abstract, Other +{ + int conduit() { return CONDUIT; } + int output() { return OUTPUT; } + int other() { return OTHER; } + int input() { return INPUT; } +} + +void main() +{ + auto impl = new Impl; + + { + auto i = impl; + assert(i.common() == COMMON); + assert(i.input() == INPUT); + assert(i.output() == OUTPUT); + assert(i.conduit() == CONDUIT); + assert(i.other() == OTHER); + } + + { + Abstract i = impl; + assert(i.common() == COMMON); + assert(i.input() == INPUT); + assert(i.output() == OUTPUT); + assert(i.conduit() == CONDUIT); + } + + { + Conduit i = impl; + assert(i.common() == COMMON); + assert(i.input() == INPUT); + assert(i.output() == OUTPUT); + assert(i.conduit() == CONDUIT); + } + + { + Output i = impl; + assert(i.output() == OUTPUT); + } + + { + Common i = impl; + assert(i.common() == COMMON); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/void1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,11 @@ +extern(C) int printf(char*, ...); + +void main() +{ + int[0][10] arr; + printf("%u\n", &arr[9] - &arr[0]); + int[0] arr1; + printf("%p\n", &arr1); + void[0] arr2; + printf("%p\n", &arr2); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/with1.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +module with1; +struct S +{ + int i; + float f; +} +void main() +{ + S s; + with(s) + { + i = 0; + f = 3.5; + } + assert(s.i == 0); + assert(s.f == 3.5); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/with2.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,17 @@ +struct bar { + int bar; +} + +void main() { + bar Bar; + with (Bar) + { + assert(Bar.bar == 0); + void test() + { + bar ++; + } + test(); + } + assert(Bar.bar == 1); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/run/mini/with3.d Mon Jan 10 19:47:18 2011 +0100 @@ -0,0 +1,21 @@ +enum fields +{ + FIELD1, + FIELD2 +} + +fields find_field(fields f) { + with(fields) { + switch(f) { + case FIELD1: + return FIELD1; + default: + return FIELD2; + } + } +} + +void main() { + assert(find_field(fields.FIELD1) == fields.FIELD1); + assert(find_field(fields.FIELD2) == fields.FIELD2); +}