1 // PERMUTE_ARGS:
2 
3 // Test memset style array assignments.
4 
5 extern(C) int printf(const char*, ...);
6 
7 /**************************************/
8 
9 char[] b1;
10 
11 char[] func1(int dim)
12 {
13     char[] a = new char[dim];
14 
15     b1 = a;
16     return a;
17 }
18 
19 void test1()
20 {
21     printf("test1()\n");
22     int i;
23     int j;
24 
25     char[1] a1;
26     a1[] = 'x';
27     assert(a1[0] == 'x');
28 
29     char[2] a2;
30     a2[] = 'x';
31     for (i = 0; i < a2.length; i++)
32         assert(a2[i] == 'x');
33 
34     char[3] a3;
35     a3[] = 'x';
36     for (i = 0; i < a3.length; i++)
37         assert(a3[i] == 'x');
38 
39     char[4] a4;
40     a4[] = 'x';
41     for (i = 0; i < a4.length; i++)
42         assert(a4[i] == 'x');
43 
44     char[8] a8;
45     a8[] = 'x';
46     for (i = 0; i < a8.length; i++)
47         assert(a8[i] == 'x');
48 
49     char[27] a27;
50     a27[] = 'x';
51     for (i = 0; i < a27.length; i++)
52         assert(a27[i] == 'x');
53 
54     func1(33)[] = 'y';
55     for (i = 0; i < b1.length; i++)
56         assert(b1[i] == 'y');
57 
58 
59     char[23] a23 = 'x';
60     i = 16;
61     j = 18;
62     a23[i++..++j] = 'c';
63     printf("i = %d, j = %d\n", i, j);
64     assert(i == 17);
65     assert(j == 19);
66     assert(a23[15] == 'x');
67     assert(a23[16] == 'c');
68     assert(a23[17] == 'c');
69     assert(a23[18] == 'c');
70     assert(a23[19] == 'x');
71     assert(a23[20] == 'x');
72 }
73 
74 /**************************************/
75 
76 short[] b2;
77 
78 short[] func2(int dim)
79 {
80     short[] a = new short[dim];
81 
82     b2 = a;
83     return a;
84 }
85 
86 void test2()
87 {
88     printf("test2()\n");
89     int i;
90     int j;
91 
92     short[1] a1;
93     a1[] = 0x1234;
94     assert(a1[0] == 0x1234);
95 
96     short[2] a2;
97     a2[] = 0x1234;
98     for (i = 0; i < a2.length; i++)
99         assert(a2[i] == 0x1234);
100 
101     short[3] a3;
102     a3[] = 0x1234;
103     for (i = 0; i < a3.length; i++)
104         assert(a3[i] == 0x1234);
105 
106     short[4] a4;
107     a4[] = 0x1234;
108     for (i = 0; i < a4.length; i++)
109         assert(a4[i] == 0x1234);
110 
111     short[8] a8;
112     a8[] = 0x1234;
113     for (i = 0; i < a8.length; i++)
114         assert(a8[i] == 0x1234);
115 
116     short[27] a27;
117     a27[] = 0x1234;
118     for (i = 0; i < a27.length; i++)
119         assert(a27[i] == 0x1234);
120 
121     func2(33)[] = 0x5678;
122     for (i = 0; i < b2.length; i++)
123         assert(b2[i] == 0x5678);
124 
125 
126     short[23] a23 = 0x1234;
127     i = 16;
128     j = 18;
129     a23[i++..++j] = 0x4554;
130     printf("i = %d, j = %d\n", i, j);
131     assert(i == 17);
132     assert(j == 19);
133     assert(a23[15] == 0x1234);
134     assert(a23[16] == 0x4554);
135     assert(a23[17] == 0x4554);
136     assert(a23[18] == 0x4554);
137     assert(a23[19] == 0x1234);
138     assert(a23[20] == 0x1234);
139 }
140 
141 /**************************************/
142 
143 int[] b3;
144 
145 int[] func3(int dim)
146 {
147     int[] a = new int[dim];
148 
149     b3 = a;
150     return a;
151 }
152 
153 void test3()
154 {
155     printf("test3()\n");
156     int i;
157     int j;
158 
159     int[1] a1;
160     a1[] = 0x12345678;
161     assert(a1[0] == 0x12345678);
162 
163     int[2] a2;
164     a2[] = 0x12345678;
165     for (i = 0; i < a2.length; i++)
166         assert(a2[i] == 0x12345678);
dissect_fb_zero_tag(tvbuff_t * tvb,packet_info * pinfo,proto_tree * fb_zero_tree,guint offset,guint32 tag_number)167 
168     int[3] a3;
169     a3[] = 0x12345678;
170     for (i = 0; i < a3.length; i++)
171         assert(a3[i] == 0x12345678);
172 
173     int[4] a4;
174     a4[] = 0x12345678;
175     for (i = 0; i < a4.length; i++)
176         assert(a4[i] == 0x12345678);
177 
178     int[8] a8;
179     a8[] = 0x12345678;
180     for (i = 0; i < a8.length; i++)
181         assert(a8[i] == 0x12345678);
182 
183     int[27] a27;
184     a27[] = 0x12345678;
185     for (i = 0; i < a27.length; i++)
186         assert(a27[i] == 0x12345678);
187 
188     func3(33)[] = 0x56781234;
189     for (i = 0; i < b3.length; i++)
190         assert(b3[i] == 0x56781234);
191 
192 
193     int[23] a23 = 0x12345678;
194     i = 16;
195     j = 18;
196     a23[i++..++j] = 0x45546776;
197     printf("i = %d, j = %d\n", i, j);
198     assert(i == 17);
199     assert(j == 19);
200     assert(a23[15] == 0x12345678);
201     assert(a23[16] == 0x45546776);
202     assert(a23[17] == 0x45546776);
203     assert(a23[18] == 0x45546776);
204     assert(a23[19] == 0x12345678);
205     assert(a23[20] == 0x12345678);
206 }
207 
208 /**************************************/
209 
210 long[] b4;
211 
212 long[] func4(int dim)
213 {
214     long[] a = new long[dim];
215 
216     b4 = a;
217     return a;
218 }
219 
220 void test4()
221 {
222     printf("test4()\n");
223     int i;
224     int j;
225 
226     long[1] a1;
227     a1[] = 0x123456789ABCDEF0;
228     assert(a1[0] == 0x123456789ABCDEF0);
229 
230     long[2] a2;
231     a2[] = 0x123456789ABCDEF0;
232     for (i = 0; i < a2.length; i++)
233         assert(a2[i] == 0x123456789ABCDEF0);
234 
235     long[3] a3;
236     a3[] = 0x123456789ABCDEF0;
237     for (i = 0; i < a3.length; i++)
238         assert(a3[i] == 0x123456789ABCDEF0);
239 
240     long[4] a4;
241     a4[] = 0x123456789ABCDEF0;
242     for (i = 0; i < a4.length; i++)
243         assert(a4[i] == 0x123456789ABCDEF0);
244 
245     long[8] a8;
246     a8[] = 0x123456789ABCDEF0;
247     for (i = 0; i < a8.length; i++)
248         assert(a8[i] == 0x123456789ABCDEF0);
249 
250     long[27] a27;
251     a27[] = 0x123456789ABCDEF0;
252     for (i = 0; i < a27.length; i++)
253         assert(a27[i] == 0x123456789ABCDEF0);
254 
255     func4(33)[] = 0x5678889911223344;
256     for (i = 0; i < b4.length; i++)
257         assert(b4[i] == 0x5678889911223344);
258 
259 
260     long[23] a23 = 0x123456789ABCDEF0;
261     i = 16;
262     j = 18;
263     a23[i++..++j] = 0x567888991122334B;
264     printf("i = %d, j = %d\n", i, j);
265     assert(i == 17);
266     assert(j == 19);
267     assert(a23[15] == 0x123456789ABCDEF0);
268     assert(a23[16] == 0x567888991122334B);
269     assert(a23[17] == 0x567888991122334B);
270     assert(a23[18] == 0x567888991122334B);
271     assert(a23[19] == 0x123456789ABCDEF0);
272     assert(a23[20] == 0x123456789ABCDEF0);
273 }
274 
275 /**************************************/
276 
277 real[] b5;
278 
279 real[] func5(int dim)
280 {
281     real[] a = new real[dim];
282 
283     b5 = a;
284     return a;
285 }
286 
287 void test5()
288 {
289     printf("test5()\n");
290     int i;
291     int j;
292 
293     real[1] a1;
294     a1[] = 31234;
295     assert(a1[0] == 31234);
296 
297     real[2] a2;
298     a2[] = 31234;
299     for (i = 0; i < a2.length; i++)
300         assert(a2[i] == 31234);
301 
302     real[3] a3;
303     a3[] = 31234;
304     for (i = 0; i < a3.length; i++)
305         assert(a3[i] == 31234);
306 
307     real[4] a4;
308     a4[] = 31234;
309     for (i = 0; i < a4.length; i++)
310         assert(a4[i] == 31234);
311 
312     real[8] a8;
313     a8[] = 31234;
314     for (i = 0; i < a8.length; i++)
315         assert(a8[i] == 31234);
316 
317     real[27] a27;
318     a27[] = 31234;
319     for (i = 0; i < a27.length; i++)
320         assert(a27[i] == 31234);
321 
322     func5(33)[] = 35678;
323     for (i = 0; i < b5.length; i++)
324         assert(b5[i] == 35678);
325 
326 
327     real[23] a23 = 31234;
328     i = 16;
329     j = 18;
330     a23[i++..++j] = 34554e+4;
331     printf("i = %d, j = %d\n", i, j);
332     assert(i == 17);
333     assert(j == 19);
334     assert(a23[15] == 31234);
335     assert(a23[16] == 34554e+4);
336     assert(a23[17] == 34554e+4);
337     assert(a23[18] == 34554e+4);
338     assert(a23[19] == 31234);
339     assert(a23[20] == 31234);
340 }
341 
342 /**************************************/
343 
344 struct ABC
345 {
346     int a,b,c,d;
347 }
348 
349 ABC abc1 = { a:1, b:2, c:3, d:4 };
350 ABC abc2 = { a:7, b:6, c:8, d:9 };
351 ABC abc3 = { a:5, b:10, c:11, d:12 };
352 
353 ABC[] b6;
354 
355 ABC[] func6(int dim)
356 {
357     ABC[] a = new ABC[dim];
358 
359     b6 = a;
360     return a;
361 }
362 
363 void test6()
364 {
365     printf("test6()\n");
366     int i;
367     int j;
368 
369     ABC[1] a1;
370     a1[] = abc1;
371     assert(a1[0] == abc1);
372 
373     ABC[2] a2;
374     a2[] = abc1;
375     for (i = 0; i < a2.length; i++)
376         assert(a2[i] == abc1);
377 
378     ABC[3] a3;
379     a3[] = abc1;
380     for (i = 0; i < a3.length; i++)
381         assert(a3[i] == abc1);
382 
dissect_fb_zero_unencrypt(tvbuff_t * tvb,packet_info * pinfo,proto_tree * fb_zero_tree,guint offset,guint8 len_pkn _U_)383     ABC[4] a4;
384     a4[] = abc1;
385     for (i = 0; i < a4.length; i++)
386         assert(a4[i] == abc1);
387 
388     ABC[8] a8;
389     a8[] = abc1;
390     for (i = 0; i < a8.length; i++)
391         assert(a8[i] == abc1);
392 
393     ABC[27] a27;
394     a27[] = abc1;
395     for (i = 0; i < a27.length; i++)
396         assert(a27[i] == abc1);
397 
398     func6(33)[] = abc2;
399     for (i = 0; i < b6.length; i++)
400         assert(b6[i] == abc2);
401 
402 
403     ABC[23] a23 = abc1;
404     i = 16;
405     j = 18;
406     a23[i++..++j] = abc3;
407     printf("i = %d, j = %d\n", i, j);
408     assert(i == 17);
409     assert(j == 19);
410     assert(a23[15] == abc1);
411     assert(a23[16] == abc3);
412     assert(a23[17] == abc3);
413     assert(a23[18] == abc3);
414     assert(a23[19] == abc1);
415     assert(a23[20] == abc1);
416 }
417 
418 /**************************************/
419 
420 bool[] b7;
421 
422 bool[] func7(int dim)
423 {
424     bool[] a = new bool[dim];
425 
426     b7 = a;
427     return a;
428 }
dissect_fb_zero_common(tvbuff_t * tvb,packet_info * pinfo,proto_tree * tree,void * data _U_)429 
430 void test7()
431 {
432     printf("test7()\n");
433     int i;
434     int j;
435 
436     bool[1] a1;
437     a1[] = 1;
438     assert(a1[0] == 1);
439 
440     bool[2] a2;
441     a2[] = 1;
442     for (i = 0; i < a2.length; i++)
443         assert(a2[i] == 1);
444 
445     bool[3] a3;
446     a3[] = 1;
447     for (i = 0; i < a3.length; i++)
448         assert(a3[i] == 1);
449 
450     bool[4] a4;
451     a4[] = 1;
452     for (i = 0; i < a4.length; i++)
453         assert(a4[i] == 1);
454 
455     bool[8] a8;
456     a8[] = 1;
457     for (i = 0; i < a8.length; i++)
458         assert(a8[i] == 1);
459 
460     bool[27] a27;
461     a27[] = 1;
462     for (i = 0; i < a27.length; i++)
463         assert(a27[i] == 1);
464 
465     func7(33)[] = 1;
466     assert(b7.length == 33);
467     for (i = 0; i < b7.length; i++)
468         assert(b7[i] == 1);
469 
470     func7(33)[3..6] = 1;
471     //printf("b7.ptr = %p, b7.length = %d\n", b7.ptr, b7.length);
472     assert(b7.length == 33);
473     for (i = 0; i < b7.length; i++)
474     {
475         //printf("b7[%d] = %d\n", i, b7[i]);
476         if (i >= 3 && i < 6)
477             assert(b7[i] == 1);
478         else
479             assert(b7[i] == 0);
480     }
481 
482     bool[23] a23 = 1;
483     i = 16;
484     j = 18;
485     a23[i++..++j] = 0;
486     printf("i = %d, j = %d\n", i, j);
487     assert(i == 17);
488     assert(j == 19);
489     assert(a23[15] == 1);
490     assert(a23[16] == 0);
491     assert(a23[17] == 0);
492     assert(a23[18] == 0);
493     assert(a23[19] == 1);
494     assert(a23[20] == 1);
495 
496 }
497 
498 /**************************************/
499 
500 bool[] slice8(bool[] b)
501 {
502     return b[8..16];
503 }
504 
505 void test8()
506 {
507     bool[16] b;
508     bool[] b2;
509     b[9] = true;
510     b2 = slice8(b);
511     assert(b2.length == 8);
512     assert(b2[1] == true);
513     b[9] = false;
514     assert(b2[1] == false);
515 }
516 
517 
518 /**************************************/
519 
520 bool[] slice9(bool[] b, int i, int j)
521 {
proto_register_fb_zero(void)522     return b[i..j];
523 }
524 
525 void test9()
526 {
527     bool[17] b;
528     bool[] b2;
529     b[9] = true;
530     b[16] = true;
531     b2 = slice9(b,8,17);
532     assert(b2.length == 9);
533     assert(b2[1] == true);
534     assert(b2[8] == true);
535     b[9] = false;
536     b[16] = false;
537     assert(b2[1] == false);
538     assert(b2[8] == false);
539 }
540 
541 
542 /**************************************/
543 
544 bool* foo10(bool[] b, int i)
545 {
546     return &b[i];
547 }
548 
549 void test10()
550 {
551     bool[17] b;
552     bool* pb;
553 
554     b[8] = true;
555     b[9] = true;
556     pb = foo10(b, 8);
557     assert(*pb == true);
558     b[8] = false;
559     assert(*pb == false);
560 }
561 
562 /**************************************/
563 
564 bool* foo11(bool[] b, int i)
565 {
566     return &b[i];
567 }
568 
569 void test11()
570 {
571     bool[17] b;
572     bool* pb;
573 
574     b[9] = true;
575     b[10] = true;
576     pb = foo11(b, 8);
577     assert(pb[1] == true);
578     b[9] = false;
579     assert(pb[1] == false);
580 }
581 
582 
583 /**************************************/
584 
585 bool* foo12(bool[] b, int i)
586 {
587     return &b[i];
588 }
589 
590 void test12()
591 {
592     bool[17] b;
593     bool* pb;
594 
595     b[9] = true;
596     b[10] = true;
597     pb = foo12(b, 0);
598     pb = pb + 8;
599     assert(pb[1] == true);
600     b[9] = false;
601     assert(pb[1] == false);
602 }
603 
604 /**************************************/
605 
606 bool* foo13(bool* b, int i)
607 {
608     return &b[i];
609 }
610 
611 void test13()
612 {
613     bool[17] b;
614     bool* pb;
615 
616     b[9] = true;
617     b[10] = true;
618     pb = foo13(b.ptr, 8);
619     assert(pb[1] == true);
620     b[9] = false;
621     assert(pb[1] == false);
622 }
623 
624 /**************************************/
625 
626 void test14()
627 {
628     bool b = true;
629     assert(b);
630     b = !b;
631     assert(!b);
632 }
633 
634 /**************************************/
635 
636 void test15()
637 {
638    bool b = 1;
639    bool *pb = &b;
640    *pb = false;
641    assert(!b);
642 }
643 
644 
645 /**************************************/
646 
647 void foo16(bool[] b1, bool[] b2)
648 {
649     b1[0..3] = b2[8..11];
650 }
651 
652 void test16()
653 {
654     static bool[16] b1 = [1,1,0,1,0,0,0,0];
655     static bool[16] b2 = [0,0,0,0,0,0,0,0, 0,0,1,0,1,1,1,1];
656 
657     foo16(b1, b2);
658     assert(b1[0] == false);
659     assert(b1[1] == false);
660     assert(b1[2] == true);
661     assert(b1[3] == true);
662     assert(b1[4] == false);
663     assert(b1[5] == false);
664     assert(b1[6] == false);
665     assert(b1[7] == false);
666     assert(b1[8] == false);
667 }
668 
669 /**************************************/
670 
671 void test17()
672 {
673   bool bi = true;
674   byte by;
675 
676   by=bi;
677   assert(by == 1);
678 }
679 
680 
681 /**************************************/
682 
683 void test18()
684 {
685     bool b = 1;
686     bool c = 1;
687     b |= cast(bool)(3 + c);
proto_reg_handoff_fb_zero(void)688     assert(b == true);
689 }
690 
691 
692 /**************************************/
693 
694 void test19()
695 {
696         int i;
697         for (i = 0; i < 10; i++){
698                 version(dummy) i=22;
699         }
700         assert(i==10);
701 
702         char[][] args;
703         foreach(char[] p; args){
704                 version(dummy) int i;
705         }
706 }
707 
708 /**************************************/
709 
710 int main()
711 {
712     test1();
713     test2();
714     test3();
715     test4();
716     test5();
717     test6();
718     test7();
719     test8();
720     test9();
721     test10();
722     test11();
723     test12();
724     test13();
725     test14();
726     test15();
727     test16();
728     test17();
729     test18();
730     test19();
731 
732     printf("Success\n");
733     return 0;
734 }
735