1 // RUNNABLE_PHOBOS_TEST
2 // REQUIRED_ARGS:
3
4 import std.math: poly;
5 import core.stdc.stdarg;
6
7 extern(C)
8 {
9 int printf(const char*, ...);
version(Windows)10 version(Windows)
11 {
12 int _snprintf(char*, size_t, const char*, ...);
13 alias _snprintf snprintf;
14 }
15 else
16 int snprintf(char*, size_t, const char*, ...);
17 }
18
19 /*************************************/
20
21 // http://www.digitalmars.com/d/archives/digitalmars/D/bugs/4766.html
22 // Only with -O
23
randx()24 real randx()
25 {
26 return 1.2;
27 }
28
test1()29 void test1()
30 {
31 float x10=randx();
32 float x11=randx();
33 float x20=randx();
34 float x21=randx();
35 float y10=randx();
36 float y11=randx();
37 float y20=randx();
38 float y21=randx();
39
40 float tmp=(
41 x20*x21 + y10*y10 + y10*y11 + y11*y11 +
42 y11*y20 + y20*y20 + y10*y21 + y11*y21 +
43 y21*y21);
44 assert(tmp > 0);
45 }
46
47 /*************************************/
48
test2()49 void test2()
50 {
51 double x10=randx();
52 double x11=randx();
53 double x20=randx();
54 double x21=randx();
55 double y10=randx();
56 double y11=randx();
57 double y20=randx();
58 double y21=randx();
59
60 double tmp=(
61 x20*x21 + y10*y10 + y10*y11 + y11*y11 +
62 y11*y20 + y20*y20 + y10*y21 + y11*y21 +
63 y21*y21);
64 assert(tmp > 0);
65 }
66
67 /*************************************/
68
test3()69 void test3()
70 {
71 real x10=randx();
72 real x11=randx();
73 real x20=randx();
74 real x21=randx();
75 real y10=randx();
76 real y11=randx();
77 real y20=randx();
78 real y21=randx();
79
80 real tmp=(
81 x20*x21 + y10*y10 + y10*y11 + y11*y11 +
82 y11*y20 + y20*y20 + y10*y21 + y11*y21 +
83 y21*y21);
84 assert(tmp > 0);
85 }
86
87 /*************************************/
88
test4()89 void test4()
90 {
91 printf("main() : (-128 >= 0)=%s, (-128 <= 0)=%s\n",
92 cast(char*)(-128 >= 0 ? "true" : "false"),
93 cast(char*)(-128 <= 0 ? "true" : "false"));
94
95 printf("main() : (128 >= 0)=%s, (128 <= 0)=%s\n",
96 cast(char*)(128 >= 0 ? "true" : "false"),
97 cast(char*)(128 <= 0 ? "true" : "false"));
98
99 assert((-128 >= 0 ? "true" : "false") == "false"),
100 assert((-128 <= 0 ? "true" : "false") == "true");
101 assert((+128 >= 0 ? "true" : "false") == "true"),
102 assert((+128 <= 0 ? "true" : "false") == "false");
103 }
104
105
106 /*************************************/
107
foo5()108 int foo5() { assert(0); } // No return.
109
abc5()110 int abc5()
111 {
112 printf("foo = %d\n", foo5());
113 return 0;
114 }
115
test5()116 void test5()
117 {
118 }
119
120 /*************************************/
121
test6()122 void test6()
123 {
124 ireal a = 6.5i % 3i;
125 printf("%Lfi %Lfi\n", a, a - .5i);
126 assert(a == .5i);
127
128 a = 6.5i % 3;
129 printf("%Lfi %Lfi\n", a, a - .5i);
130 assert(a == .5i);
131
132 real b = 6.5 % 3i;
133 printf("%Lf %Lf\n", b, b - .5);
134 assert(b == .5);
135
136 b = 6.5 % 3;
137 printf("%Lf %Lf\n", b, b - .5);
138 assert(b == .5);
139 }
140
141 /*************************************/
142
test7()143 void test7()
144 {
145 cfloat f = 1+0i;
146 f %= 2fi;
147 printf("%f + %fi\n", f.re, f.im);
148 assert(f == 1 + 0i);
149
150 cdouble d = 1+0i;
151 d %= 2i;
152 printf("%f + %fi\n", d.re, d.im);
153 assert(d == 1 + 0i);
154
155 creal r = 1+0i;
156 r %= 2i;
157 printf("%Lf + %Lfi\n", r.re, r.im);
158 assert(r == 1 + 0i);
159 }
160
161 /*************************************/
162
test8()163 void test8()
164 {
165 cfloat f = 1+0i;
166 f %= 2i;
167 printf("%f + %fi\n", f.re, f.im);
168 assert(f == 1);
169
170 cdouble d = 1+0i;
171 d = d % 2i;
172 printf("%f + %fi\n", d.re, d.im);
173 assert(d == 1);
174
175 creal r = 1+0i;
176 r = r % 2i;
177 printf("%Lf + %Lfi\n", r.re, r.im);
178 assert(r == 1);
179 }
180
181 /*************************************/
182
183 class A9
184 {
this(int[]params...)185 this(int[] params ...)
186 {
187 for (int i = 0; i < params.length; i++)
188 {
189 assert(params[i] == i + 1);
190 }
191 }
192 }
193
194 class B9
195 {
this()196 this()
197 {
198 init();
199 }
200
init()201 private void init()
202 {
203 A9 test1 = new A9(1, 2, 3);
204 A9 test2 = new A9(1, 2, 3, 4);
205 int[3] arg;
206 arg[0]=1, arg[1]=2, arg[2]=3;
207 A9 test3 = new A9(arg);
208 }
209 }
210
test9()211 void test9()
212 {
213 B9 test2 = new B9();
214 }
215
216 /*************************************/
217
test10()218 void test10()
219 {
220 auto i = 5u;
221 auto s = typeid(typeof(i)).toString;
222 printf("%.*s\n", s.length, s.ptr);
223 assert(typeid(typeof(i)) == typeid(uint));
224 }
225
226 /*************************************/
227
test11()228 void test11()
229 {
230 printf("%d\n", 3);
231 printf("xhello world!\n");
232 }
233
234 /*************************************/
235
236 void assertEqual(real* a, real* b, string file = __FILE__, size_t line = __LINE__)
237 {
238 auto x = cast(ubyte*)a;
239 auto y = cast(ubyte*)b;
240
241 // Only compare the 10 value bytes, the padding bytes are of undefined
242 // value.
243 version (X86) enum count = 10;
244 else version (X86_64) enum count = 10;
245 else enum count = real.sizeof;
246 for (size_t i = 0; i < count; i++)
247 {
248 if (x[i] != y[i])
249 {
250 printf("%02d: %02x %02x\n", i, x[i], y[i]);
251 import core.exception;
252 throw new AssertError(file, line);
253 }
254 }
255 }
256
257 void assertEqual(creal* a, creal* b, string file = __FILE__, size_t line = __LINE__)
258 {
259 assertEqual(cast(real*)a, cast(real*)b, file, line);
260 assertEqual(cast(real*)a + 1, cast(real*)b + 1, file, line);
261 }
262
test12()263 void test12()
264 {
265 creal a = creal.nan;
266 creal b = real.nan + ireal.nan;
267 assertEqual(&a, &b);
268
269 real c= real.nan;
270 real d=a.re;
271 assertEqual(&c, &d);
272
273 d=a.im;
274 assertEqual(&c, &d);
275 }
276
277 /*************************************/
278
test13()279 void test13()
280 {
281 creal a = creal.infinity;
282 creal b = real.infinity + ireal.infinity;
283 assertEqual(&a, &b);
284
285 real c = real.infinity;
286 real d=a.re;
287 assertEqual(&c, &d);
288
289 d=a.im;
290 assertEqual(&c, &d);
291 }
292
293 /*************************************/
294
test14()295 void test14()
296 {
297 creal a = creal.nan;
298 creal b = creal.nan;
299 b = real.nan + ireal.nan;
300 assertEqual(&a, &b);
301
302 real c = real.nan;
303 real d=a.re;
304 assertEqual(&c, &d);
305
306 d=a.im;
307 assertEqual(&c, &d);
308 }
309
310 /*************************************/
311
312 ireal x15;
313
foo15()314 void foo15()
315 {
316 x15 = -x15;
317 }
318
bar15()319 void bar15()
320 {
321 return foo15();
322 }
323
test15()324 void test15()
325 {
326 x15=2i;
327 bar15();
328 assert(x15==-2i);
329 }
330
331 /*************************************/
332
333 real x16;
334
foo16()335 void foo16()
336 {
337 x16 = -x16;
338 }
339
bar16()340 void bar16()
341 {
342 return foo16();
343 }
344
test16()345 void test16()
346 {
347 x16=2;
348 bar16();
349 assert(x16==-2);
350 }
351
352 /*************************************/
353
354 class Bar17
355 {
this(...)356 this(...) {}
357 }
358
359 class Foo17
360 {
opAdd(Bar17 b)361 void opAdd (Bar17 b) {}
362 }
363
test17()364 void test17()
365 {
366 auto f = new Foo17;
367 f + new Bar17;
368 }
369
370
371 /*************************************/
372
u18(int n)373 template u18(int n)
374 {
375 static if (n==1) {
376 int a = 1;
377 } else
378 int b = 4;
379 }
380
test18()381 void test18()
382 {
383 mixin u18!(2);
384 assert(b == 4);
385 }
386
387 /*************************************/
388
389 class DP
390 {
391 private:
I(char[]p)392 void I(char[] p)
393 {
394 I(p[1..p.length]);
395 }
396 }
397
test19()398 void test19()
399 {
400 }
401
402 /*************************************/
403
404 struct Struct20
405 {
406 int i;
407 }
408
test20()409 void test20()
410 {
411 auto s = new Struct20;
412 s.i = 7;
413 }
414
415 /*************************************/
416
C21(float f)417 class C21(float f)
418 {
419 float ff = f;
420 }
421
test21()422 void test21()
423 {
424 auto a = new C21!(1.2);
425 C21!(1.2) b = new C21!(1.2);
426 }
427
428 /*************************************/
429
test22()430 void test22()
431 {
432 static creal[] params = [1+0i, 3+0i, 5+0i];
433
434 printf("params[0] = %Lf + %Lfi\n", params[0].re, params[0].im);
435 printf("params[1] = %Lf + %Lfi\n", params[1].re, params[1].im);
436 printf("params[2] = %Lf + %Lfi\n", params[2].re, params[2].im);
437
438 creal[] sums = new creal[3];
439 sums[] = 0+0i;
440
441 foreach(creal d; params)
442 {
443 creal prod = d;
444
445 printf("prod = %Lf + %Lfi\n", prod.re, prod.im);
446 for(int i; i<2; i++)
447 {
448 sums[i] += prod;
449 prod *= d;
450 }
451 sums[2] += prod;
452 }
453
454 printf("sums[0] = %Lf + %Lfi", sums[0].re, sums[0].im);
455 assert(sums[0].re==9);
456 assert(sums[0].im==0);
457 assert(sums[1].re==35);
458 assert(sums[1].im==0);
459 assert(sums[2].re==153);
460 assert(sums[2].im==0);
461 }
462
463 /*************************************/
464
465 const int c23 = b23 * b23;
466 const int a23 = 1;
467 const int b23 = a23 * 3;
468
T23(int n)469 template T23(int n)
470 {
471 int[n] x23;
472 }
473
474 mixin T23!(c23);
475
test23()476 void test23()
477 {
478 assert(x23.length==9);
479 }
480
481 /*************************************/
482
func_24_1(ifloat f,double d)483 ifloat func_24_1(ifloat f, double d)
484 {
485 // f /= cast(cdouble)d;
486 return f;
487 }
488
func_24_2(ifloat f,double d)489 ifloat func_24_2(ifloat f, double d)
490 {
491 f = cast(ifloat)(f / cast(cdouble)d);
492 return f;
493 }
494
func_24_3(float f,double d)495 float func_24_3(float f, double d)
496 {
497 // f /= cast(cdouble)d;
498 return f;
499 }
500
func_24_4(float f,double d)501 float func_24_4(float f, double d)
502 {
503 f = cast(float)(f / cast(cdouble)d);
504 return f;
505 }
506
test24()507 void test24()
508 {
509 ifloat f = func_24_1(10i, 8);
510 printf("%fi\n", f);
511 // assert(f == 1.25i);
512
513 f = func_24_2(10i, 8);
514 printf("%fi\n", f);
515 assert(f == 1.25i);
516
517 float g = func_24_3(10, 8);
518 printf("%f\n", g);
519 // assert(g == 1.25);
520
521 g = func_24_4(10, 8);
522 printf("%f\n", g);
523 assert(g == 1.25);
524 }
525
526 /*************************************/
527
cat(int n)528 template cat(int n)
529 {
530 const int dog = n;
531 }
532
533 const char [] bird = "canary";
534
535 const int sheep = cat!(bird.length).dog;
536
test25()537 void test25()
538 {
539 assert(sheep == 6);
540 }
541
542 /*************************************/
543
toString26(cdouble z)544 string toString26(cdouble z)
545 {
546 char[ulong.sizeof*8] buf;
547
548 auto len = snprintf(buf.ptr, buf.sizeof, "%f+%fi", z.re, z.im);
549 return buf[0 .. len].idup;
550 }
551
test26()552 void test26()
553 {
554 static cdouble[] A = [1+0i, 0+1i, 1+1i];
555 string s;
556
557 foreach( cdouble z; A )
558 {
559 s = toString26(z);
560 printf("%.*s ", s.length, s.ptr);
561 }
562 printf("\n");
563
564 for(int ii=0; ii<A.length; ii++ )
565 A[ii] += -1i*A[ii];
566
567 assert(A[0] == 1 - 1i);
568 assert(A[1] == 1 + 1i);
569 assert(A[2] == 2);
570
571 foreach( cdouble z; A )
572 {
573 s = toString26(z);
574 printf("%.*s ", s.length, s.ptr);
575 }
576 printf("\n");
577 }
578
579 /*************************************/
580
test27()581 void test27()
582 { int x;
583
584 string s = (int*function(int ...)[]).mangleof;
585 printf("%.*s\n", s.length, s.ptr);
586 assert((int*function(int ...)[]).mangleof == "APFiXPi");
587 assert(typeof(x).mangleof == "i");
588 assert(x.mangleof == "_D6test226test27FZ1xi");
589 }
590
591 /*************************************/
592
test28()593 void test28()
594 {
595 alias cdouble X;
596 X four = cast(X) (4.0i + 0.4);
597 }
598
599 /*************************************/
600
test29()601 void test29()
602 {
603 ulong a = 10_000_000_000_000_000,
604 b = 1_000_000_000_000_000;
605
606 printf("test29\n%lx\n%lx\n%lx\n", a, b, a / b);
607 assert((a / b) == 10);
608 }
609
610 static assert((10_000_000_000_000_000 / 1_000_000_000_000_000) == 10);
611
612 /*************************************/
613
chook(int n)614 template chook(int n)
615 {
616 const int chook = 3;
617 }
618
dog(alias f)619 template dog(alias f) {
620 const int dog = chook!(f.mangleof.length);
621 }
622
623 class pig {}
624
625 const int goose = dog!(pig);
626
test30()627 void test30()
628 {
629 printf("%d\n", goose);
630 assert(goose == 3);
631 }
632
633 /*************************************/
634
dog31(string sheep)635 template dog31(string sheep)
636 {
637 immutable string dog31 = "daschund";
638 }
639
test31()640 void test31()
641 {
642 string duck = dog31!("bird"[1..3]);
643
644 assert(duck == "daschund");
645 }
646
647 /*************************************/
648
649 struct particle
650 {
651 int active; /* Active (Yes/No) */
652 float life; /* Particle Life */
653 float fade; /* Fade Speed */
654
655 float r; /* Red Value */
656 float g; /* Green Value */
657 float b; /* Blue Value */
658
659 float x; /* X Position */
660 float y; /* Y Position */
661
662 float xi; /* X Direction */
663 float yi; /* Y Direction */
664
665 float xg; /* X Gravity */
666 float yg; /* Y Gravity */
667 }
668
669 particle particles[10000];
670
test32()671 void test32()
672 {
673 }
674
675 /*************************************/
676
677 class Foo33
678 {
foo()679 template foo()
680 {
681 int foo() { return 6; }
682 }
683 }
684
685
test33()686 void test33()
687 {
688 Foo33 f = new Foo33;
689
690 assert(f.foo!()() == 6);
691 with (f)
692 assert(foo!()() == 6);
693 }
694
695 /*************************************/
696
dog34(string duck)697 template dog34(string duck)
698 {
699 const int dog34 = 2;
700 }
701
test34()702 void test34()
703 {
704 int aardvark = dog34!("cat" ~ "pig");
705
706 assert(aardvark == 2);
707 }
708
709 /*************************************/
710
711 class A35
712 {
713 private bool quit;
halt()714 void halt() {quit = true;}
isHalted()715 bool isHalted() {return quit;}
716 }
717
test35()718 void test35()
719 {
720 auto a = new A35;
721
722 a.halt; // error here
723 a.halt();
724
725 a.isHalted; // error here
726 bool done = a.isHalted;
727 if (a.isHalted)
728 {
729 }
730 }
731
732
733 /*************************************/
734
test36()735 void test36()
736 {
737 bool q = (0.9 + 3.5L == 0.9L + 3.5L);
738 assert(q);
739 static assert(0.9 + 3.5L == 0.9L + 3.5L);
740 assert(0.9 + 3.5L == 0.9L + 3.5L);
741 }
742
743 /*************************************/
744
Foo37(T)745 abstract class Foo37(T)
746 {
747 void bar () { }
748 }
749
750 class Bar37 : Foo37!(int)
751 {
752 }
753
test37()754 void test37()
755 {
756 auto f = new Bar37;
757 }
758
759 /*************************************/
760
test38()761 void test38()
762 {
763 auto s=`hello`;
764 assert(s.length==5);
765 assert(s[0]=='h');
766 assert(s[1]=='e');
767 assert(s[2]=='l');
768 assert(s[3]=='l');
769 assert(s[4]=='o');
770 }
771
772 /*************************************/
773
test39()774 void test39()
775 {
776 int value=1;
777 string key = "eins";
778 int[char[]] array;
779
780 array[key]=value;
781 int* ptr = key in array;
782
783 assert(value == *ptr);
784 }
785
786 /*************************************/
787
test40()788 void test40()
789 {
790 auto s=r"hello";
791 assert(s.length==5);
792 assert(s[0]=='h');
793 assert(s[1]=='e');
794 assert(s[2]=='l');
795 assert(s[3]=='l');
796 assert(s[4]=='o');
797 }
798
799 /*************************************/
800
test41()801 void test41()
802 {
803 version (Windows)
804 {
805 version(D_InlineAsm){
806 double a = 1.2;
807 double b = 0.2;
808 double c = 1.4;
809
810 asm{
811 movq XMM0, a;
812 movq XMM1, b;
813 addsd XMM1, XMM0;
814 movq c, XMM1;
815 }
816
817 a += b;
818
819 b = a-c;
820 b = (b>0) ? b : (-1 * b);
821
822 assert(b < b.epsilon*4);
823 }
824 }
825 }
826
827 /*************************************/
828
829 const char[] tapir = "some horned animal";
830
831 const byte[] antelope = cast(byte []) tapir;
832
test42()833 void test42()
834 {
835 }
836
837 /*************************************/
838
test43()839 void test43()
840 {
841 string armadillo = "abc" ~ 'a';
842 assert(armadillo == "abca");
843 string armadillo2 = 'b' ~ "abc";
844 assert(armadillo2 == "babc");
845 }
846
847 /*************************************/
848
849 const uint baboon44 = 3;
850
851 const int monkey44 = 4;
852
853 const ape44 = monkey44 * baboon44;
854
test44()855 void test44()
856 {
857 assert(ape44 == 12);
858 }
859
860 /*************************************/
861
862 class A45
863 {
this()864 this()
865 {
866 b = new B();
867 b.x = 5; // illegal
868 }
869
870 class B
871 {
872 protected int x;
873 }
874
875 B b;
876 }
877
test45()878 void test45()
879 {
880 }
881
882
883 /*************************************/
884
C46(T)885 class C46(T)
886 {
887 private T i; // or protected or package
888 }
889
test46()890 void test46()
891 {
892 C46!(int) c = new C46!(int); // class t4.C46!(int).C46 member i is not accessible
893 c.i = 10;
894 }
895
896 /*************************************/
897
bug5809()898 void bug5809()
899 {
900 ushort[2] x = void;
901 x[0] = 0;
902 x[1] = 0x1234;
903 ushort *px = &x[0];
904
905 uint b = px[0];
906
907 assert(px[0] == 0);
908 }
909
910 /*************************************/
911
bug7546()912 void bug7546()
913 {
914 double p = -0.0;
915 assert(p == 0);
916 }
917
918
919 /*************************************/
920
poly_asm(real x,real[]A)921 real poly_asm(real x, real[] A)
922 in
923 {
924 assert(A.length > 0);
925 }
926 body
927 {
version(D_InlineAsm_X86)928 version (D_InlineAsm_X86)
929 {
930 version (linux)
931 {
932 asm // assembler by W. Bright
933 {
934 // EDX = (A.length - 1) * real.sizeof
935 mov ECX,A[EBP] ; // ECX = A.length
936 dec ECX ;
937 lea EDX,[ECX][ECX*8] ;
938 add EDX,ECX ;
939 add EDX,ECX ;
940 add EDX,ECX ;
941 add EDX,A+4[EBP] ;
942 fld real ptr [EDX] ; // ST0 = coeff[ECX]
943 jecxz return_ST ;
944 fld x[EBP] ; // ST0 = x
945 fxch ST(1) ; // ST1 = x, ST0 = r
946 align 4 ;
947 L2: fmul ST,ST(1) ; // r *= x
948 fld real ptr -12[EDX] ;
949 sub EDX,12 ; // deg--
950 faddp ST(1),ST ;
951 dec ECX ;
952 jne L2 ;
953 fxch ST(1) ; // ST1 = r, ST0 = x
954 fstp ST(0) ; // dump x
955 align 4 ;
956 return_ST: ;
957 ;
958 }
959 }
960 else version (OSX)
961 {
962 asm // assembler by W. Bright
963 {
964 // EDX = (A.length - 1) * real.sizeof
965 mov ECX,A[EBP] ; // ECX = A.length
966 dec ECX ;
967 lea EDX,[ECX*8] ;
968 add EDX,EDX ;
969 add EDX,A+4[EBP] ;
970 fld real ptr [EDX] ; // ST0 = coeff[ECX]
971 jecxz return_ST ;
972 fld x[EBP] ; // ST0 = x
973 fxch ST(1) ; // ST1 = x, ST0 = r
974 align 4 ;
975 L2: fmul ST,ST(1) ; // r *= x
976 fld real ptr -16[EDX] ;
977 sub EDX,16 ; // deg--
978 faddp ST(1),ST ;
979 dec ECX ;
980 jne L2 ;
981 fxch ST(1) ; // ST1 = r, ST0 = x
982 fstp ST(0) ; // dump x
983 align 4 ;
984 return_ST: ;
985 ;
986 }
987 }
988 else version (FreeBSD)
989 {
990 asm // assembler by W. Bright
991 {
992 // EDX = (A.length - 1) * real.sizeof
993 mov ECX,A[EBP] ; // ECX = A.length
994 dec ECX ;
995 lea EDX,[ECX][ECX*8] ;
996 add EDX,ECX ;
997 add EDX,ECX ;
998 add EDX,ECX ;
999 add EDX,A+4[EBP] ;
1000 fld real ptr [EDX] ; // ST0 = coeff[ECX]
1001 jecxz return_ST ;
1002 fld x[EBP] ; // ST0 = x
1003 fxch ST(1) ; // ST1 = x, ST0 = r
1004 align 4 ;
1005 L2: fmul ST,ST(1) ; // r *= x
1006 fld real ptr -12[EDX] ;
1007 sub EDX,12 ; // deg--
1008 faddp ST(1),ST ;
1009 dec ECX ;
1010 jne L2 ;
1011 fxch ST(1) ; // ST1 = r, ST0 = x
1012 fstp ST(0) ; // dump x
1013 align 4 ;
1014 return_ST: ;
1015 ;
1016 }
1017 }
1018 else version (Solaris)
1019 {
1020 asm // assembler by W. Bright
1021 {
1022 // EDX = (A.length - 1) * real.sizeof
1023 mov ECX,A[EBP] ; // ECX = A.length
1024 dec ECX ;
1025 lea EDX,[ECX][ECX*8] ;
1026 add EDX,ECX ;
1027 add EDX,ECX ;
1028 add EDX,ECX ;
1029 add EDX,A+4[EBP] ;
1030 fld real ptr [EDX] ; // ST0 = coeff[ECX]
1031 jecxz return_ST ;
1032 fld x[EBP] ; // ST0 = x
1033 fxch ST(1) ; // ST1 = x, ST0 = r
1034 align 4 ;
1035 L2: fmul ST,ST(1) ; // r *= x
1036 fld real ptr -12[EDX] ;
1037 sub EDX,12 ; // deg--
1038 faddp ST(1),ST ;
1039 dec ECX ;
1040 jne L2 ;
1041 fxch ST(1) ; // ST1 = r, ST0 = x
1042 fstp ST(0) ; // dump x
1043 align 4 ;
1044 return_ST: ;
1045 ;
1046 }
1047 }
1048 else
1049 {
1050 asm // assembler by W. Bright
1051 {
1052 // EDX = (A.length - 1) * real.sizeof
1053 mov ECX,A[EBP] ; // ECX = A.length
1054 dec ECX ;
1055 lea EDX,[ECX][ECX*8] ;
1056 add EDX,ECX ;
1057 add EDX,A+4[EBP] ;
1058 fld real ptr [EDX] ; // ST0 = coeff[ECX]
1059 jecxz return_ST ;
1060 fld x[EBP] ; // ST0 = x
1061 fxch ST(1) ; // ST1 = x, ST0 = r
1062 align 4 ;
1063 L2: fmul ST,ST(1) ; // r *= x
1064 fld real ptr -10[EDX] ;
1065 sub EDX,10 ; // deg--
1066 faddp ST(1),ST ;
1067 dec ECX ;
1068 jne L2 ;
1069 fxch ST(1) ; // ST1 = r, ST0 = x
1070 fstp ST(0) ; // dump x
1071 align 4 ;
1072 return_ST: ;
1073 ;
1074 }
1075 }
1076 }
1077 else
1078 {
1079 printf("Sorry, you don't seem to have InlineAsm_X86\n");
1080 return 0;
1081 }
1082 }
1083
poly_c(real x,real[]A)1084 real poly_c(real x, real[] A)
1085 in
1086 {
1087 assert(A.length > 0);
1088 }
1089 body
1090 {
1091 ptrdiff_t i = A.length - 1;
1092 real r = A[i];
1093 while (--i >= 0)
1094 {
1095 r *= x;
1096 r += A[i];
1097 }
1098 return r;
1099 }
1100
test47()1101 void test47()
1102 {
1103 real x = 3.1;
1104 static real pp[] = [56.1, 32.7, 6];
1105 real r;
1106
1107 printf("The result should be %Lf\n",(56.1L + (32.7L + 6L * x) * x));
1108 printf("The C version outputs %Lf\n", poly_c(x, pp));
1109 printf("The asm version outputs %Lf\n", poly_asm(x, pp));
1110 printf("The std.math version outputs %Lf\n", poly(x, pp));
1111
1112 r = (56.1L + (32.7L + 6L * x) * x);
1113 assert(r == poly_c(x, pp));
1114 version (D_InlineAsm_X86)
1115 assert(r == poly_asm(x, pp));
1116 assert(r == poly(x, pp));
1117 }
1118
1119 /*************************************/
1120
1121 const c48 = 1uL-1;
1122
test48()1123 void test48()
1124 {
1125 assert(c48 == 0);
1126 }
1127
1128 /*************************************/
1129
cat49()1130 template cat49()
1131 {
1132 static assert(1); // OK
1133 static if (1)
1134 {
1135 static assert(1); // doesn't work
1136 static if (1)
1137 {
1138 static assert(1); // OK
1139 const int cat49 = 3;
1140 }
1141 }
1142 }
1143
test49()1144 void test49()
1145 {
1146 const int a = cat49!();
1147 assert(a == 3);
1148 }
1149
1150 /*************************************/
1151
test50()1152 void test50()
1153 {
1154 if (auto x = 1)
1155 {
1156 assert(typeid(typeof(x)) == typeid(int));
1157 assert(x == 1);
1158 }
1159 else
1160 assert(0);
1161
1162 if (int x = 1)
1163 {
1164 assert(typeid(typeof(x)) == typeid(int));
1165 assert(x == 1);
1166 }
1167 else
1168 assert(0);
1169
1170 if (1)
1171 {
1172 }
1173 else
1174 assert(0);
1175 }
1176
1177 /*************************************/
1178
test51()1179 void test51()
1180 {
1181 bool b;
1182 assert(b == false);
1183 b &= 1;
1184 assert(b == false);
1185 b |= 1;
1186 assert(b == true);
1187 b ^= 1;
1188 assert(b == false);
1189 b = b | true;
1190 assert(b == true);
1191 b = b & false;
1192 assert(b == false);
1193 b = b ^ true;
1194 assert(b == true);
1195 b = !b;
1196 assert(b == false);
1197 }
1198
1199 /*************************************/
1200
1201 alias int function (int) x52;
1202
T52(string str)1203 template T52(string str){
1204 const int T52 = 1;
1205 }
1206
1207 static assert(T52!(x52.mangleof));
1208
test52()1209 void test52()
1210 {
1211 }
1212
1213 /*************************************/
1214 import std.stdio;
1215 import core.stdc.stdarg;
1216
myfunc(int a1,...)1217 void myfunc(int a1, ...) {
1218 va_list argument_list;
1219 TypeInfo argument_type;
1220 string sa; int ia; double da;
1221 writefln("%d variable arguments", _arguments.length);
1222 writefln("argument types %s", _arguments);
1223 va_start(argument_list, a1);
1224 for (int i = 0; i < _arguments.length; ) {
1225 if ((argument_type=_arguments[i++]) == typeid(string)) {
1226 va_arg(argument_list, sa);
1227 writefln("%d) string arg = '%s', length %d", i+1, sa.length<=20? sa : "?", sa.length);
1228 } else if (argument_type == typeid(int)) {
1229 va_arg(argument_list, ia);
1230 writefln("%d) int arg = %d", i+1, ia);
1231 } else if (argument_type == typeid(double)) {
1232 va_arg(argument_list, da);
1233 writefln("%d) double arg = %f", i+1, da);
1234 } else {
1235 throw new Exception("invalid argument type");
1236 }
1237 }
1238 va_end(argument_list);
1239 }
1240
test6758()1241 void test6758() {
1242 myfunc(1, 2, 3, 4, 5, 6, 7, 8, "9", "10"); // Fails.
1243 myfunc(1, 2.0, 3, 4, 5, 6, 7, 8, "9", "10"); // Works OK.
1244 myfunc(1, 2, 3, 4, 5, 6, 7, "8", "9", "10"); // Works OK.
1245 myfunc(1, "2", 3, 4, 5, 6, 7, 8, "9", "10"); // Works OK.
1246 }
1247
1248
1249 /*************************************/
1250
main()1251 int main()
1252 {
1253 test1();
1254 test2();
1255 test3();
1256 test4();
1257 test5();
1258 test6();
1259 test7();
1260 test8();
1261 test9();
1262 test10();
1263 test11();
1264 test12();
1265 test13();
1266 test14();
1267 test15();
1268 test16();
1269 test17();
1270 test18();
1271 test19();
1272 test20();
1273 test21();
1274 test22();
1275 test23();
1276 test24();
1277 test25();
1278 test26();
1279 test27();
1280 test28();
1281 test29();
1282 test30();
1283 test31();
1284 test32();
1285 test33();
1286 test34();
1287 test35();
1288 test36();
1289 test37();
1290 test38();
1291 test39();
1292 test40();
1293 test41();
1294 test42();
1295 test43();
1296 test44();
1297 test45();
1298 test46();
1299 bug5809();
1300 bug7546();
1301 test47();
1302 test48();
1303 test49();
1304 test50();
1305 test51();
1306 test52();
1307 test6758();
1308
1309 printf("Success\n");
1310 return 0;
1311 }
1312