| // REQUIRED_ARGS: |
| |
| import core.stdc.stdarg; |
| |
| extern(C) |
| { |
| int printf(const char*, ...); |
| version(Windows) |
| { |
| int _snprintf(char*, size_t, const char*, ...); |
| alias _snprintf snprintf; |
| } |
| else |
| int snprintf(char*, size_t, const char*, ...); |
| } |
| |
| /*************************************/ |
| |
| // https://www.digitalmars.com/d/archives/digitalmars/D/bugs/4766.html |
| // Only with -O |
| |
| real randx() |
| { |
| return 1.2; |
| } |
| |
| void test1() |
| { |
| float x10=randx(); |
| float x11=randx(); |
| float x20=randx(); |
| float x21=randx(); |
| float y10=randx(); |
| float y11=randx(); |
| float y20=randx(); |
| float y21=randx(); |
| |
| float tmp=( |
| x20*x21 + y10*y10 + y10*y11 + y11*y11 + |
| y11*y20 + y20*y20 + y10*y21 + y11*y21 + |
| y21*y21); |
| assert(tmp > 0); |
| } |
| |
| /*************************************/ |
| |
| void test2() |
| { |
| double x10=randx(); |
| double x11=randx(); |
| double x20=randx(); |
| double x21=randx(); |
| double y10=randx(); |
| double y11=randx(); |
| double y20=randx(); |
| double y21=randx(); |
| |
| double tmp=( |
| x20*x21 + y10*y10 + y10*y11 + y11*y11 + |
| y11*y20 + y20*y20 + y10*y21 + y11*y21 + |
| y21*y21); |
| assert(tmp > 0); |
| } |
| |
| /*************************************/ |
| |
| void test3() |
| { |
| real x10=randx(); |
| real x11=randx(); |
| real x20=randx(); |
| real x21=randx(); |
| real y10=randx(); |
| real y11=randx(); |
| real y20=randx(); |
| real y21=randx(); |
| |
| real tmp=( |
| x20*x21 + y10*y10 + y10*y11 + y11*y11 + |
| y11*y20 + y20*y20 + y10*y21 + y11*y21 + |
| y21*y21); |
| assert(tmp > 0); |
| } |
| |
| /*************************************/ |
| |
| void test4() |
| { |
| printf("main() : (-128 >= 0)=%s, (-128 <= 0)=%s\n", |
| cast(char*)(-128 >= 0 ? "true" : "false"), |
| cast(char*)(-128 <= 0 ? "true" : "false")); |
| |
| printf("main() : (128 >= 0)=%s, (128 <= 0)=%s\n", |
| cast(char*)(128 >= 0 ? "true" : "false"), |
| cast(char*)(128 <= 0 ? "true" : "false")); |
| |
| assert((-128 >= 0 ? "true" : "false") == "false"), |
| assert((-128 <= 0 ? "true" : "false") == "true"); |
| assert((+128 >= 0 ? "true" : "false") == "true"), |
| assert((+128 <= 0 ? "true" : "false") == "false"); |
| } |
| |
| |
| /*************************************/ |
| |
| int foo5() { assert(0); } // No return. |
| |
| int abc5() |
| { |
| printf("foo = %d\n", foo5()); |
| return 0; |
| } |
| |
| void test5() |
| { |
| } |
| |
| /*************************************/ |
| |
| class A9 |
| { |
| this(int[] params ...) |
| { |
| for (int i = 0; i < params.length; i++) |
| { |
| assert(params[i] == i + 1); |
| } |
| } |
| } |
| |
| class B9 |
| { |
| this() |
| { |
| init(); |
| } |
| |
| private void init() |
| { |
| A9 test1 = new A9(1, 2, 3); |
| A9 test2 = new A9(1, 2, 3, 4); |
| int[3] arg; |
| arg[0]=1, arg[1]=2, arg[2]=3; |
| A9 test3 = new A9(arg); |
| } |
| } |
| |
| void test9() |
| { |
| B9 test2 = new B9(); |
| } |
| |
| /*************************************/ |
| |
| void test10() |
| { |
| auto i = 5u; |
| auto s = typeid(typeof(i)).toString; |
| printf("%.*s\n", cast(int)s.length, s.ptr); |
| assert(typeid(typeof(i)) == typeid(uint)); |
| } |
| |
| /*************************************/ |
| |
| void test11() |
| { |
| printf("%d\n", 3); |
| printf("xhello world!\n"); |
| } |
| |
| /*************************************/ |
| |
| real x16; |
| |
| void foo16() |
| { |
| x16 = -x16; |
| } |
| |
| void bar16() |
| { |
| return foo16(); |
| } |
| |
| void test16() |
| { |
| x16=2; |
| bar16(); |
| assert(x16==-2); |
| } |
| |
| /*************************************/ |
| |
| class Bar17 |
| { |
| this(...) {} |
| } |
| |
| class Foo17 |
| { |
| void opBinary(string op : "+") (Bar17 b) {} |
| } |
| |
| void test17() |
| { |
| auto f = new Foo17; |
| f + new Bar17; |
| } |
| |
| |
| /*************************************/ |
| |
| template u18(int n) |
| { |
| static if (n==1) { |
| int a = 1; |
| } else |
| int b = 4; |
| } |
| |
| void test18() |
| { |
| mixin u18!(2); |
| assert(b == 4); |
| } |
| |
| /*************************************/ |
| |
| class DP |
| { |
| private: |
| void I(char[] p) |
| { |
| I(p[1..p.length]); |
| } |
| } |
| |
| void test19() |
| { |
| } |
| |
| /*************************************/ |
| |
| struct Struct20 |
| { |
| int i; |
| } |
| |
| void test20() |
| { |
| auto s = new Struct20; |
| s.i = 7; |
| } |
| |
| /*************************************/ |
| |
| class C21(float f) |
| { |
| float ff = f; |
| } |
| |
| void test21() |
| { |
| auto a = new C21!(1.2); |
| C21!(1.2) b = new C21!(1.2); |
| } |
| |
| /*************************************/ |
| |
| const int c23 = b23 * b23; |
| const int a23 = 1; |
| const int b23 = a23 * 3; |
| |
| template T23(int n) |
| { |
| int[n] x23; |
| } |
| |
| mixin T23!(c23); |
| |
| void test23() |
| { |
| assert(x23.length==9); |
| } |
| |
| /*************************************/ |
| |
| template cat(int n) |
| { |
| const int dog = n; |
| } |
| |
| const char [] bird = "canary"; |
| |
| const int sheep = cat!(bird.length).dog; |
| |
| void test25() |
| { |
| assert(sheep == 6); |
| } |
| |
| /*************************************/ |
| |
| void test27() |
| { int x; |
| |
| string s = (int*function(int ...)[]).mangleof; |
| printf("%.*s\n", cast(int)s.length, s.ptr); |
| assert((int*function(int ...)[]).mangleof == "APFiXPi"); |
| assert(typeof(x).mangleof == "i"); |
| assert(x.mangleof == "_D6test226test27FZ1xi"); |
| } |
| |
| /*************************************/ |
| |
| void test29() |
| { |
| ulong a = 10_000_000_000_000_000, |
| b = 1_000_000_000_000_000; |
| |
| printf("test29\n%llx\n%llx\n%llx\n", a, b, a / b); |
| assert((a / b) == 10); |
| } |
| |
| static assert((10_000_000_000_000_000 / 1_000_000_000_000_000) == 10); |
| |
| /*************************************/ |
| |
| template chook(int n) |
| { |
| const int chook = 3; |
| } |
| |
| template dog(alias f) { |
| const int dog = chook!(f.mangleof.length); |
| } |
| |
| class pig {} |
| |
| const int goose = dog!(pig); |
| |
| void test30() |
| { |
| printf("%d\n", goose); |
| assert(goose == 3); |
| } |
| |
| /*************************************/ |
| |
| template dog31(string sheep) |
| { |
| immutable string dog31 = "daschund"; |
| } |
| |
| void test31() |
| { |
| string duck = dog31!("bird"[1..3]); |
| |
| assert(duck == "daschund"); |
| } |
| |
| /*************************************/ |
| |
| struct particle |
| { |
| int active; /* Active (Yes/No) */ |
| float life; /* Particle Life */ |
| float fade; /* Fade Speed */ |
| |
| float r; /* Red Value */ |
| float g; /* Green Value */ |
| float b; /* Blue Value */ |
| |
| float x; /* X Position */ |
| float y; /* Y Position */ |
| |
| float xi; /* X Direction */ |
| float yi; /* Y Direction */ |
| |
| float xg; /* X Gravity */ |
| float yg; /* Y Gravity */ |
| } |
| |
| particle[10000] particles; |
| |
| void test32() |
| { |
| } |
| |
| /*************************************/ |
| |
| class Foo33 |
| { |
| template foo() |
| { |
| int foo() { return 6; } |
| } |
| } |
| |
| |
| void test33() |
| { |
| Foo33 f = new Foo33; |
| |
| assert(f.foo!()() == 6); |
| with (f) |
| assert(foo!()() == 6); |
| } |
| |
| /*************************************/ |
| |
| template dog34(string duck) |
| { |
| const int dog34 = 2; |
| } |
| |
| void test34() |
| { |
| int aardvark = dog34!("cat" ~ "pig"); |
| |
| assert(aardvark == 2); |
| } |
| |
| /*************************************/ |
| |
| class A35 |
| { |
| private bool quit; |
| void halt() {quit = true;} |
| bool isHalted() {return quit;} |
| } |
| |
| void test35() |
| { |
| auto a = new A35; |
| |
| a.halt; // error here |
| a.halt(); |
| |
| a.isHalted; // error here |
| bool done = a.isHalted; |
| if (a.isHalted) |
| { |
| } |
| } |
| |
| |
| /*************************************/ |
| |
| void test36() |
| { |
| bool q = (0.9 + 3.5L == 0.9L + 3.5L); |
| assert(q); |
| static assert(0.9 + 3.5L == 0.9L + 3.5L); |
| assert(0.9 + 3.5L == 0.9L + 3.5L); |
| } |
| |
| /*************************************/ |
| |
| abstract class Foo37(T) |
| { |
| void bar () { } |
| } |
| |
| class Bar37 : Foo37!(int) |
| { |
| } |
| |
| void test37() |
| { |
| auto f = new Bar37; |
| } |
| |
| /*************************************/ |
| |
| void test38() |
| { |
| auto s=`hello`; |
| assert(s.length==5); |
| assert(s[0]=='h'); |
| assert(s[1]=='e'); |
| assert(s[2]=='l'); |
| assert(s[3]=='l'); |
| assert(s[4]=='o'); |
| } |
| |
| /*************************************/ |
| |
| void test39() |
| { |
| int value=1; |
| string key = "eins"; |
| int[char[]] array; |
| |
| array[key]=value; |
| int* ptr = key in array; |
| |
| assert(value == *ptr); |
| } |
| |
| /*************************************/ |
| |
| void test40() |
| { |
| auto s=r"hello"; |
| assert(s.length==5); |
| assert(s[0]=='h'); |
| assert(s[1]=='e'); |
| assert(s[2]=='l'); |
| assert(s[3]=='l'); |
| assert(s[4]=='o'); |
| } |
| |
| /*************************************/ |
| |
| void test41() |
| { |
| version (Windows) |
| { |
| version(D_InlineAsm){ |
| double a = 1.2; |
| double b = 0.2; |
| double c = 1.4; |
| |
| asm{ |
| movq XMM0, a; |
| movq XMM1, b; |
| addsd XMM1, XMM0; |
| movq c, XMM1; |
| } |
| |
| a += b; |
| |
| b = a-c; |
| b = (b>0) ? b : (-1 * b); |
| |
| assert(b < b.epsilon*4); |
| } |
| } |
| } |
| |
| /*************************************/ |
| |
| const char[] tapir = "some horned animal"; |
| |
| const byte[] antelope = cast(byte []) tapir; |
| |
| void test42() |
| { |
| } |
| |
| /*************************************/ |
| |
| void test43() |
| { |
| string armadillo = "abc" ~ 'a'; |
| assert(armadillo == "abca"); |
| string armadillo2 = 'b' ~ "abc"; |
| assert(armadillo2 == "babc"); |
| } |
| |
| /*************************************/ |
| |
| const uint baboon44 = 3; |
| |
| const int monkey44 = 4; |
| |
| const ape44 = monkey44 * baboon44; |
| |
| void test44() |
| { |
| assert(ape44 == 12); |
| } |
| |
| /*************************************/ |
| |
| class A45 |
| { |
| this() |
| { |
| b = new B(); |
| b.x = 5; // illegal |
| } |
| |
| class B |
| { |
| protected int x; |
| } |
| |
| B b; |
| } |
| |
| void test45() |
| { |
| } |
| |
| |
| /*************************************/ |
| |
| class C46(T) |
| { |
| private T i; // or protected or package |
| } |
| |
| void test46() |
| { |
| C46!(int) c = new C46!(int); // class t4.C46!(int).C46 member i is not accessible |
| c.i = 10; |
| } |
| |
| /*************************************/ |
| |
| void bug5809() |
| { |
| ushort[2] x = void; |
| x[0] = 0; |
| x[1] = 0x1234; |
| ushort *px = &x[0]; |
| |
| uint b = px[0]; |
| |
| assert(px[0] == 0); |
| } |
| |
| /*************************************/ |
| |
| void bug7546() |
| { |
| double p = -0.0; |
| assert(p == 0); |
| } |
| |
| |
| /*************************************/ |
| |
| real poly_asm(real x, real[] A) |
| in |
| { |
| assert(A.length > 0); |
| } |
| do |
| { |
| version (D_InlineAsm_X86) |
| { |
| version (linux) |
| { |
| asm // assembler by W. Bright |
| { |
| // EDX = (A.length - 1) * real.sizeof |
| mov ECX,A[EBP] ; // ECX = A.length |
| dec ECX ; |
| lea EDX,[ECX][ECX*8] ; |
| add EDX,ECX ; |
| add EDX,ECX ; |
| add EDX,ECX ; |
| add EDX,A+4[EBP] ; |
| fld real ptr [EDX] ; // ST0 = coeff[ECX] |
| jecxz return_ST ; |
| fld x[EBP] ; // ST0 = x |
| fxch ST(1) ; // ST1 = x, ST0 = r |
| align 4 ; |
| L2: fmul ST,ST(1) ; // r *= x |
| fld real ptr -12[EDX] ; |
| sub EDX,12 ; // deg-- |
| faddp ST(1),ST ; |
| dec ECX ; |
| jne L2 ; |
| fxch ST(1) ; // ST1 = r, ST0 = x |
| fstp ST(0) ; // dump x |
| align 4 ; |
| return_ST: ; |
| ; |
| } |
| } |
| else version (OSX) |
| { |
| asm // assembler by W. Bright |
| { |
| // EDX = (A.length - 1) * real.sizeof |
| mov ECX,A[EBP] ; // ECX = A.length |
| dec ECX ; |
| lea EDX,[ECX*8] ; |
| add EDX,EDX ; |
| add EDX,A+4[EBP] ; |
| fld real ptr [EDX] ; // ST0 = coeff[ECX] |
| jecxz return_ST ; |
| fld x[EBP] ; // ST0 = x |
| fxch ST(1) ; // ST1 = x, ST0 = r |
| align 4 ; |
| L2: fmul ST,ST(1) ; // r *= x |
| fld real ptr -16[EDX] ; |
| sub EDX,16 ; // deg-- |
| faddp ST(1),ST ; |
| dec ECX ; |
| jne L2 ; |
| fxch ST(1) ; // ST1 = r, ST0 = x |
| fstp ST(0) ; // dump x |
| align 4 ; |
| return_ST: ; |
| ; |
| } |
| } |
| else version (FreeBSD) |
| { |
| asm // assembler by W. Bright |
| { |
| // EDX = (A.length - 1) * real.sizeof |
| mov ECX,A[EBP] ; // ECX = A.length |
| dec ECX ; |
| lea EDX,[ECX][ECX*8] ; |
| add EDX,ECX ; |
| add EDX,ECX ; |
| add EDX,ECX ; |
| add EDX,A+4[EBP] ; |
| fld real ptr [EDX] ; // ST0 = coeff[ECX] |
| jecxz return_ST ; |
| fld x[EBP] ; // ST0 = x |
| fxch ST(1) ; // ST1 = x, ST0 = r |
| align 4 ; |
| L2: fmul ST,ST(1) ; // r *= x |
| fld real ptr -12[EDX] ; |
| sub EDX,12 ; // deg-- |
| faddp ST(1),ST ; |
| dec ECX ; |
| jne L2 ; |
| fxch ST(1) ; // ST1 = r, ST0 = x |
| fstp ST(0) ; // dump x |
| align 4 ; |
| return_ST: ; |
| ; |
| } |
| } |
| else version (Solaris) |
| { |
| asm // assembler by W. Bright |
| { |
| // EDX = (A.length - 1) * real.sizeof |
| mov ECX,A[EBP] ; // ECX = A.length |
| dec ECX ; |
| lea EDX,[ECX][ECX*8] ; |
| add EDX,ECX ; |
| add EDX,ECX ; |
| add EDX,ECX ; |
| add EDX,A+4[EBP] ; |
| fld real ptr [EDX] ; // ST0 = coeff[ECX] |
| jecxz return_ST ; |
| fld x[EBP] ; // ST0 = x |
| fxch ST(1) ; // ST1 = x, ST0 = r |
| align 4 ; |
| L2: fmul ST,ST(1) ; // r *= x |
| fld real ptr -12[EDX] ; |
| sub EDX,12 ; // deg-- |
| faddp ST(1),ST ; |
| dec ECX ; |
| jne L2 ; |
| fxch ST(1) ; // ST1 = r, ST0 = x |
| fstp ST(0) ; // dump x |
| align 4 ; |
| return_ST: ; |
| ; |
| } |
| } |
| else |
| { |
| asm // assembler by W. Bright |
| { |
| // EDX = (A.length - 1) * real.sizeof |
| mov ECX,A[EBP] ; // ECX = A.length |
| dec ECX ; |
| lea EDX,[ECX][ECX*8] ; |
| add EDX,ECX ; |
| add EDX,A+4[EBP] ; |
| fld real ptr [EDX] ; // ST0 = coeff[ECX] |
| jecxz return_ST ; |
| fld x[EBP] ; // ST0 = x |
| fxch ST(1) ; // ST1 = x, ST0 = r |
| align 4 ; |
| L2: fmul ST,ST(1) ; // r *= x |
| fld real ptr -10[EDX] ; |
| sub EDX,10 ; // deg-- |
| faddp ST(1),ST ; |
| dec ECX ; |
| jne L2 ; |
| fxch ST(1) ; // ST1 = r, ST0 = x |
| fstp ST(0) ; // dump x |
| align 4 ; |
| return_ST: ; |
| ; |
| } |
| } |
| } |
| else |
| { |
| printf("Sorry, you don't seem to have InlineAsm_X86\n"); |
| return 0; |
| } |
| } |
| |
| real poly_c(real x, real[] A) |
| in |
| { |
| assert(A.length > 0); |
| } |
| do |
| { |
| ptrdiff_t i = A.length - 1; |
| real r = A[i]; |
| while (--i >= 0) |
| { |
| r *= x; |
| r += A[i]; |
| } |
| return r; |
| } |
| |
| void test47() |
| { |
| real x = 3.1; |
| static real[] pp = [56.1, 32.7, 6]; |
| real r; |
| |
| printf("The result should be %Lf\n",(56.1L + (32.7L + 6L * x) * x)); |
| printf("The C version outputs %Lf\n", poly_c(x, pp)); |
| printf("The asm version outputs %Lf\n", poly_asm(x, pp)); |
| |
| r = (56.1L + (32.7L + 6L * x) * x); |
| assert(r == poly_c(x, pp)); |
| version (D_InlineAsm_X86) |
| assert(r == poly_asm(x, pp)); |
| } |
| |
| /*************************************/ |
| |
| const c48 = 1uL-1; |
| |
| void test48() |
| { |
| assert(c48 == 0); |
| } |
| |
| /*************************************/ |
| |
| template cat49() |
| { |
| static assert(1); // OK |
| static if (1) |
| { |
| static assert(1); // doesn't work |
| static if (1) |
| { |
| static assert(1); // OK |
| const int cat49 = 3; |
| } |
| } |
| } |
| |
| void test49() |
| { |
| const int a = cat49!(); |
| assert(a == 3); |
| } |
| |
| /*************************************/ |
| |
| void test50() |
| { |
| if (auto x = 1) |
| { |
| assert(typeid(typeof(x)) == typeid(int)); |
| assert(x == 1); |
| } |
| else |
| assert(0); |
| |
| if (int x = 1) |
| { |
| assert(typeid(typeof(x)) == typeid(int)); |
| assert(x == 1); |
| } |
| else |
| assert(0); |
| |
| if (1) |
| { |
| } |
| else |
| assert(0); |
| } |
| |
| /*************************************/ |
| |
| void test51() |
| { |
| bool b; |
| assert(b == false); |
| b &= 1; |
| assert(b == false); |
| b |= 1; |
| assert(b == true); |
| b ^= 1; |
| assert(b == false); |
| b = b | true; |
| assert(b == true); |
| b = b & false; |
| assert(b == false); |
| b = b ^ true; |
| assert(b == true); |
| b = !b; |
| assert(b == false); |
| } |
| |
| /*************************************/ |
| |
| alias int function (int) x52; |
| |
| template T52(string str){ |
| const int T52 = 1; |
| } |
| |
| static assert(T52!(x52.mangleof)); |
| |
| void test52() |
| { |
| } |
| |
| /*************************************/ |
| |
| void myfunc(int a1, ...) { |
| va_list argument_list; |
| TypeInfo argument_type; |
| string sa; int ia; double da; |
| assert(_arguments.length == 9); |
| |
| va_start(argument_list, a1); |
| for (int i = 0; i < _arguments.length; ) { |
| if ((argument_type=_arguments[i++]) == typeid(string)) { |
| va_arg(argument_list, sa); |
| switch (i) |
| { |
| case 1: assert(sa == "2"); break; |
| case 7: assert(sa == "8"); break; |
| case 8: assert(sa == "9"); break; |
| case 9: assert(sa == "10"); break; |
| default: |
| printf("i = %d\n", i); |
| assert(false); |
| } |
| } else if (argument_type == typeid(int)) { |
| va_arg(argument_list, ia); |
| assert(ia == i+1); |
| } else if (argument_type == typeid(double)) { |
| va_arg(argument_list, da); |
| const e = i+1; |
| assert((e - 0.0001) < da && da < (e + 0.0001)); |
| } else { |
| assert(false, argument_type.toString()); |
| } |
| } |
| va_end(argument_list); |
| } |
| |
| void test6758() { |
| myfunc(1, 2, 3, 4, 5, 6, 7, 8, "9", "10"); // Fails. |
| myfunc(1, 2.0, 3, 4, 5, 6, 7, 8, "9", "10"); // Works OK. |
| myfunc(1, 2, 3, 4, 5, 6, 7, "8", "9", "10"); // Works OK. |
| myfunc(1, "2", 3, 4, 5, 6, 7, 8, "9", "10"); // Works OK. |
| } |
| |
| |
| /*************************************/ |
| |
| real f18573() { return 1; } |
| |
| void test18573() |
| { |
| cast(void) f18573(); |
| cast(void) f18573(); |
| cast(void) f18573(); |
| cast(void) f18573(); |
| cast(void) f18573(); |
| cast(void) f18573(); |
| cast(void) f18573(); |
| |
| real b = 2; |
| assert(b == 2); /* fails; should pass */ |
| } |
| |
| /*************************************/ |
| |
| int main() |
| { |
| test1(); |
| test2(); |
| test3(); |
| test4(); |
| test5(); |
| test9(); |
| test10(); |
| test11(); |
| test16(); |
| test17(); |
| test18(); |
| test19(); |
| test20(); |
| test21(); |
| test23(); |
| test25(); |
| test27(); |
| test29(); |
| test30(); |
| test31(); |
| test32(); |
| test33(); |
| test34(); |
| test35(); |
| test36(); |
| test37(); |
| test38(); |
| test39(); |
| test40(); |
| test41(); |
| test42(); |
| test43(); |
| test44(); |
| test45(); |
| test46(); |
| bug5809(); |
| bug7546(); |
| test47(); |
| test48(); |
| test49(); |
| test50(); |
| test51(); |
| test52(); |
| test6758(); |
| test18573(); |
| |
| printf("Success\n"); |
| return 0; |
| } |
