1 // REQUIRED_ARGS:
2
3 import core.stdc.stdio;
4
5 /********************************************************/
6
7 //int delegate(int, char[]) *p;
8
9 class Foo
10 {
bar(int i,char[]s)11 int bar(int i, char[] s) { return 4; }
12 }
13
14 class Bar : Foo
15 {
bar(int i,char[]s)16 override int bar(int i, char[] s) { return 5; }
17 }
18
test1()19 void test1()
20 {
21 int delegate(int, char[]) dg;
22 Foo f = new Foo();
23 Bar b = new Bar();
24 int x;
25
26 dg = &f.bar;
27 x = dg(3, null);
28 assert(x == 4);
29
30 f = b;
31 dg = &f.bar;
32 x = dg(3, null);
33 assert(x == 5);
34 }
35
36 /********************************************************/
37
foo2()38 int foo2()
39 {
40 return 3;
41 }
42
test2()43 void test2()
44 {
45 int function () fp;
46
47 fp = &foo2;
48 assert(fp() == 3);
49 }
50
51 /********************************************************/
52
53 class Foo3
54 {
bar(int i,char[]s)55 int bar(int i, char[] s) { return 47; }
56
test()57 void test()
58 {
59 int delegate(int, char[]) dg;
60
61 dg = &bar;
62 printf("%d %d\n", dg(3, null), result());
63 assert(dg(3, null) == result());
64
65 dg = &this.bar;
66 printf("%d %d\n", dg(3, null), result());
67 assert(dg(3, null) == result());
68 }
69
result()70 int result() { return 47; }
71 }
72
73 class Bar3 : Foo3
74 {
bar(int i,char[]s)75 override int bar(int i, char[] s) { return 48; }
76
result()77 override int result() { return 48; }
78
test2()79 void test2()
80 {
81 int delegate(int, char[]) dg;
82
83 dg = &super.bar;
84 assert(dg(3, null) == 47);
85 }
86
87 }
88
test3()89 void test3()
90 {
91 Foo3 f = new Foo3();
92 f.test();
93
94 Bar3 b = new Bar3();
95 b.test();
96 b.test2();
97 }
98
99 /********************************************************/
100
101
foo4(int x)102 int foo4(int x) { return 1; }
foo4(char x)103 int foo4(char x) { return 2; }
foo4(int x,int y)104 int foo4(int x, int y) { return 3; }
105
test4()106 void test4()
107 {
108 int function (char) fp;
109
110 fp = &foo4;
111 assert(fp(0) == 2);
112 }
113
114 /********************************************************/
115
116 class Abc
117 {
foo1(int x)118 int foo1(int x) { return 1; }
foo1(char x)119 int foo1(char x) { return 2; }
foo1(int x,int y)120 int foo1(int x, int y) { return 3; }
121 }
122
test5()123 void test5()
124 {
125 int delegate(char) dg;
126 Abc a = new Abc();
127
128 dg = &a.foo1;
129 assert(dg(0) == 2);
130 }
131
132 /********************************************************/
133
134 int delegate(int) bar6;
135
136 int[int delegate(int)] aa6;
137
test6()138 void test6()
139 {
140 aa6[bar6] = 0;
141 }
142
143 /********************************************************/
144
foo7(void delegate (int)dg)145 void foo7(void delegate(int) dg)
146 {
147 dg(1);
148 //writefln("%s", dg(3));
149 }
150
test7()151 void test7()
152 {
153 foo7(delegate(int i)
154 {
155 printf("i = %d\n", i);
156 }
157 );
158 }
159
160 /********************************************************/
161
foo8(int delegate (int)dg)162 void foo8(int delegate(int) dg)
163 {
164 printf("%d\n", dg(3));
165 assert(dg(3) == 6);
166 }
167
test8()168 void test8()
169 {
170 foo8(delegate(int i)
171 {
172 return i * 2;
173 }
174 );
175 }
176
177 /********************************************************/
178
foo9(int delegate (int)dg)179 void foo9(int delegate(int) dg)
180 {
181 assert(dg(3) == 6);
182 }
183
test9()184 void test9()
185 {
186 foo9( (int i) { return i * 2; } );
187 }
188
189 /********************************************************/
190 // 8257
191
192 struct S8257 {
gS8257193 static int g() {
194 return 6;
195 }
196 }
197
test8257()198 void test8257()
199 {
200 S8257 s;
201 int w = 2;
202 S8257 func() { ++w; return s; }
203 auto k = &(func()).g;
204 // check that the call to func() still happened
205 assert(w == 3);
206 assert( k() == 6);
207 }
208
f8257(string m)209 auto f8257(string m)() { return &__traits(getMember, S8257.init, m); }
210 static assert (__traits(compiles, f8257!"g"()));
211
212 /********************************************************/
213
foo10(int delegate ()dg)214 void foo10(int delegate() dg)
215 {
216 assert(dg() == 6);
217 }
218
test10()219 void test10()
220 { int i = 3;
221
222 foo10( { return i * 2; } );
223 }
224
225 /********************************************************/
226
227 class A12
228 {
229 public:
230 int delegate(int, int) dgs[4];
231 int function(int, int) fps[4];
232 int delegate(int, int) dg;
233 int function(int, int) fp;
f(int x,int y)234 int f(int x, int y) {
235 printf("here ");
236 int res = x + y;
237 printf("%d\n", res);
238 return res;
239 }
240
bug_1()241 void bug_1() {
242 // fp = &f;
243 // fp(1,2);
244 dg = &f;
245 dg(1,2);
246 // fps[] = [&f, &f, &f, &(f)]; // bug 1: this line shouldn't compile
247 // this.fps[0](1, 2); // seg-faults here!
248
249 dgs[] = [&(f), &(f), &(f), &(f)]; // bug 1: why this line can't compile?
250 this.dgs[0](1, 2);
251
252 dgs[] = [&(this.f), &(this.f), &(this.f), &(this.f)];
253 this.dgs[0](1, 2);
254 }
255
256 }
257
test12()258 void test12()
259 {
260 A12 a = new A12();
261
262 a.bug_1();
263 }
264
265 /********************************************************/
266 // 1570
267
268 class A13
269 {
f()270 int f()
271 {
272 return 1;
273 }
274 }
275
276 class B13 : A13
277 {
f()278 override int f()
279 {
280 return 2;
281 }
282 }
283
test13()284 void test13()
285 {
286 B13 b = new B13;
287 assert(b.f() == 2);
288 assert(b.A13.f() == 1);
289 assert((&b.f)() == 2);
290 assert((&b.A13.f)() == 1);
291 }
292
293 /********************************************************/
294 // 2472
295
296 class A2472
297 {
foo()298 void foo() {}
299 }
300
test2472()301 void test2472()
302 {
303 auto a = new A2472;
304 auto fp1 = (&a.foo).funcptr;
305 auto dg = &a.foo;
306 auto fp2 = dg.funcptr;
307 assert(fp1 == fp2);
308 }
309
310 /********************************************************/
311
testAssign()312 void testAssign()
313 {
314 static class C
315 {
316 int a;
317 this(int a) { this.a = a; }
318 int funca() { return a; }
319 int funcb() { return a + 1; }
320 }
321
322 auto x = new C(5);
323 auto y = new C(7);
324
325 auto dg = &x.funca;
326 assert(dg() == 5);
327 dg.funcptr = &C.funcb;
328 assert(dg() == 6);
329 dg.ptr = cast(void*)y;
330 assert(dg() == 8);
331 dg.funcptr = &C.funca;
332 assert(dg() == 7);
333 }
334
335 /********************************************************/
336
main()337 int main()
338 {
339 test1();
340 test2();
341 test3();
342 test4();
343 test5();
344 test6();
345 test7();
346 test8();
347 test9();
348 test10();
349 test12();
350 test13();
351 test2472();
352 test8257();
353 testAssign();
354
355 printf("Success\n");
356 return 0;
357 }
358