OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [gcc.dg/] [redecl-3.c] - Blame information for rev 689

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 689 jeremybenn
/* Test for multiple declarations and composite types.  Includes bug
2
   13801.  */
3
/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
4
/* { dg-do compile } */
5
/* { dg-options "-g" } */
6
 
7
typedef int IA[];
8
typedef int A10[10];
9
 
10
/* Test all combinations of: a variable declared at file scope (no
11
   type specifiers, or extern, or static), or just inside a function
12
   (with extern), redeclared in an inner scope (with extern), and
13
   redeclared in an inner scope when the previous declaration is
14
   hidden (with extern, and not if the original declaration was
15
   static).  Test three times: incomplete variable types; pointers to
16
   incomplete types; functions returning such pointers.  */
17
 
18
IA a0;
19
void
20
f0 (void)
21
{
22
  sizeof(a0); /* { dg-error "incomplete" } */
23
  {
24
    extern IA a0;
25
    sizeof(a0); /* { dg-error "incomplete" } */
26
    {
27
      int a0;
28
      {
29
        extern IA a0;
30
        sizeof(a0); /* { dg-error "incomplete" } */
31
      }
32
    }
33
    sizeof(a0); /* { dg-error "incomplete" } */
34
  }
35
  sizeof(a0); /* { dg-error "incomplete" } */
36
}
37
extern A10 a0;
38
 
39
IA a1;
40
void
41
f1 (void)
42
{
43
  sizeof(a1); /* { dg-error "incomplete" } */
44
  {
45
    extern IA a1;
46
    sizeof(a1); /* { dg-error "incomplete" } */
47
    {
48
      int a1;
49
      {
50
        extern A10 a1;
51
        sizeof(a1);
52
      }
53
    }
54
    sizeof(a1); /* { dg-error "incomplete" } */
55
  }
56
  sizeof(a1); /* { dg-error "incomplete" } */
57
}
58
extern A10 a1;
59
 
60
IA a2;
61
void
62
f2 (void)
63
{
64
  sizeof(a2); /* { dg-error "incomplete" } */
65
  {
66
    extern A10 a2;
67
    sizeof(a2);
68
    {
69
      int a2;
70
      {
71
        extern IA a2;
72
        sizeof(a2); /* { dg-error "incomplete" } */
73
      }
74
    }
75
    sizeof(a2);
76
  }
77
  sizeof(a2); /* { dg-error "incomplete" } */
78
}
79
extern A10 a2;
80
 
81
IA a3;
82
void
83
f3 (void)
84
{
85
  sizeof(a3); /* { dg-error "incomplete" } */
86
  {
87
    extern A10 a3;
88
    sizeof(a3);
89
    {
90
      int a3;
91
      {
92
        extern A10 a3;
93
        sizeof(a3);
94
      }
95
    }
96
    sizeof(a3);
97
  }
98
  sizeof(a3); /* { dg-error "incomplete" } */
99
}
100
extern A10 a3;
101
 
102
A10 a4;
103
void
104
f4 (void)
105
{
106
  sizeof(a4);
107
  {
108
    extern IA a4;
109
    sizeof(a4);
110
    {
111
      int a4;
112
      {
113
        extern IA a4;
114
        sizeof(a4); /* { dg-error "incomplete" } */
115
      }
116
    }
117
    sizeof(a4);
118
  }
119
  sizeof(a4);
120
}
121
extern A10 a4;
122
 
123
A10 a5;
124
void
125
f5 (void)
126
{
127
  sizeof(a5);
128
  {
129
    extern IA a5;
130
    sizeof(a5);
131
    {
132
      int a5;
133
      {
134
        extern A10 a5;
135
        sizeof(a5);
136
      }
137
    }
138
    sizeof(a5);
139
  }
140
  sizeof(a5);
141
}
142
extern A10 a5;
143
 
144
A10 a6;
145
void
146
f6 (void)
147
{
148
  sizeof(a6);
149
  {
150
    extern A10 a6;
151
    sizeof(a6);
152
    {
153
      int a6;
154
      {
155
        extern IA a6;
156
        sizeof(a6); /* { dg-error "incomplete" } */
157
      }
158
    }
159
    sizeof(a6);
160
  }
161
  sizeof(a6);
162
}
163
extern A10 a6;
164
 
165
A10 a7;
166
void
167
f7 (void)
168
{
169
  sizeof(a7);
170
  {
171
    extern A10 a7;
172
    sizeof(a7);
173
    {
174
      int a7;
175
      {
176
        extern A10 a7;
177
        sizeof(a7);
178
      }
179
    }
180
    sizeof(a7);
181
  }
182
  sizeof(a7);
183
}
184
extern A10 a7;
185
 
186
extern IA a8;
187
void
188
f8 (void)
189
{
190
  sizeof(a8); /* { dg-error "incomplete" } */
191
  {
192
    extern IA a8;
193
    sizeof(a8); /* { dg-error "incomplete" } */
194
    {
195
      int a8;
196
      {
197
        extern IA a8;
198
        sizeof(a8); /* { dg-error "incomplete" } */
199
      }
200
    }
201
    sizeof(a8); /* { dg-error "incomplete" } */
202
  }
203
  sizeof(a8); /* { dg-error "incomplete" } */
204
}
205
extern A10 a8;
206
 
207
extern IA a9;
208
void
209
f9 (void)
210
{
211
  sizeof(a9); /* { dg-error "incomplete" } */
212
  {
213
    extern IA a9;
214
    sizeof(a9); /* { dg-error "incomplete" } */
215
    {
216
      int a9;
217
      {
218
        extern A10 a9;
219
        sizeof(a9);
220
      }
221
    }
222
    sizeof(a9); /* { dg-error "incomplete" } */
223
  }
224
  sizeof(a9); /* { dg-error "incomplete" } */
225
}
226
extern A10 a9;
227
 
228
extern IA a10;
229
void
230
f10 (void)
231
{
232
  sizeof(a10); /* { dg-error "incomplete" } */
233
  {
234
    extern A10 a10;
235
    sizeof(a10);
236
    {
237
      int a10;
238
      {
239
        extern IA a10;
240
        sizeof(a10); /* { dg-error "incomplete" } */
241
      }
242
    }
243
    sizeof(a10);
244
  }
245
  sizeof(a10); /* { dg-error "incomplete" } */
246
}
247
extern A10 a10;
248
 
249
extern IA a11;
250
void
251
f11 (void)
252
{
253
  sizeof(a11); /* { dg-error "incomplete" } */
254
  {
255
    extern A10 a11;
256
    sizeof(a11);
257
    {
258
      int a11;
259
      {
260
        extern A10 a11;
261
        sizeof(a11);
262
      }
263
    }
264
    sizeof(a11);
265
  }
266
  sizeof(a11); /* { dg-error "incomplete" } */
267
}
268
extern A10 a11;
269
 
270
extern A10 a12;
271
void
272
f12 (void)
273
{
274
  sizeof(a12);
275
  {
276
    extern IA a12;
277
    sizeof(a12);
278
    {
279
      int a12;
280
      {
281
        extern IA a12;
282
        sizeof(a12); /* { dg-error "incomplete" } */
283
      }
284
    }
285
    sizeof(a12);
286
  }
287
  sizeof(a12);
288
}
289
extern A10 a12;
290
 
291
extern A10 a13;
292
void
293
f13 (void)
294
{
295
  sizeof(a13);
296
  {
297
    extern IA a13;
298
    sizeof(a13);
299
    {
300
      int a13;
301
      {
302
        extern A10 a13;
303
        sizeof(a13);
304
      }
305
    }
306
    sizeof(a13);
307
  }
308
  sizeof(a13);
309
}
310
extern A10 a13;
311
 
312
extern A10 a14;
313
void
314
f14 (void)
315
{
316
  sizeof(a14);
317
  {
318
    extern A10 a14;
319
    sizeof(a14);
320
    {
321
      int a14;
322
      {
323
        extern IA a14;
324
        sizeof(a14); /* { dg-error "incomplete" } */
325
      }
326
    }
327
    sizeof(a14);
328
  }
329
  sizeof(a14);
330
}
331
extern A10 a14;
332
 
333
extern A10 a15;
334
void
335
f15 (void)
336
{
337
  sizeof(a15);
338
  {
339
    extern A10 a15;
340
    sizeof(a15);
341
    {
342
      int a15;
343
      {
344
        extern A10 a15;
345
        sizeof(a15);
346
      }
347
    }
348
    sizeof(a15);
349
  }
350
  sizeof(a15);
351
}
352
extern A10 a15;
353
 
354
static IA a16;
355
void
356
f16 (void)
357
{
358
  sizeof(a16); /* { dg-error "incomplete" } */
359
  {
360
    extern IA a16;
361
    sizeof(a16); /* { dg-error "incomplete" } */
362
  }
363
  sizeof(a16); /* { dg-error "incomplete" } */
364
}
365
extern A10 a16;
366
 
367
static IA a17;
368
void
369
f17 (void)
370
{
371
  sizeof(a17); /* { dg-error "incomplete" } */
372
  {
373
    extern A10 a17;
374
    sizeof(a17);
375
  }
376
  sizeof(a17); /* { dg-error "incomplete" } */
377
}
378
extern A10 a17;
379
 
380
static A10 a18;
381
void
382
f18 (void)
383
{
384
  sizeof(a18);
385
  {
386
    extern IA a18;
387
    sizeof(a18);
388
  }
389
  sizeof(a18);
390
}
391
extern A10 a18;
392
 
393
static A10 a19;
394
void
395
f19 (void)
396
{
397
  sizeof(a19);
398
  {
399
    extern A10 a19;
400
    sizeof(a19);
401
  }
402
  sizeof(a19);
403
}
404
extern A10 a19;
405
 
406
IA *b0;
407
void
408
g0 (void)
409
{
410
  sizeof(*b0); /* { dg-error "incomplete" } */
411
  {
412
    extern IA *b0;
413
    sizeof(*b0); /* { dg-error "incomplete" } */
414
    {
415
      int b0;
416
      {
417
        extern IA *b0;
418
        sizeof(*b0); /* { dg-error "incomplete" } */
419
      }
420
    }
421
    sizeof(*b0); /* { dg-error "incomplete" } */
422
  }
423
  sizeof(*b0); /* { dg-error "incomplete" } */
424
}
425
extern A10 *b0;
426
 
427
IA *b1;
428
void
429
g1 (void)
430
{
431
  sizeof(*b1); /* { dg-error "incomplete" } */
432
  {
433
    extern IA *b1;
434
    sizeof(*b1); /* { dg-error "incomplete" } */
435
    {
436
      int b1;
437
      {
438
        extern A10 *b1;
439
        sizeof(*b1);
440
      }
441
    }
442
    sizeof(*b1); /* { dg-error "incomplete" } */
443
  }
444
  sizeof(*b1); /* { dg-error "incomplete" } */
445
}
446
extern A10 *b1;
447
 
448
IA *b2;
449
void
450
g2 (void)
451
{
452
  sizeof(*b2); /* { dg-error "incomplete" } */
453
  {
454
    extern A10 *b2;
455
    sizeof(*b2);
456
    {
457
      int b2;
458
      {
459
        extern IA *b2;
460
        sizeof(*b2); /* { dg-error "incomplete" } */
461
      }
462
    }
463
    sizeof(*b2);
464
  }
465
  sizeof(*b2); /* { dg-error "incomplete" } */
466
}
467
extern A10 *b2;
468
 
469
IA *b3;
470
void
471
g3 (void)
472
{
473
  sizeof(*b3); /* { dg-error "incomplete" } */
474
  {
475
    extern A10 *b3;
476
    sizeof(*b3);
477
    {
478
      int b3;
479
      {
480
        extern A10 *b3;
481
        sizeof(*b3);
482
      }
483
    }
484
    sizeof(*b3);
485
  }
486
  sizeof(*b3); /* { dg-error "incomplete" } */
487
}
488
extern A10 *b3;
489
 
490
A10 *b4;
491
void
492
g4 (void)
493
{
494
  sizeof(*b4);
495
  {
496
    extern IA *b4;
497
    sizeof(*b4);
498
    {
499
      int b4;
500
      {
501
        extern IA *b4;
502
        sizeof(*b4); /* { dg-error "incomplete" } */
503
      }
504
    }
505
    sizeof(*b4);
506
  }
507
  sizeof(*b4);
508
}
509
extern A10 *b4;
510
 
511
A10 *b5;
512
void
513
g5 (void)
514
{
515
  sizeof(*b5);
516
  {
517
    extern IA *b5;
518
    sizeof(*b5);
519
    {
520
      int b5;
521
      {
522
        extern A10 *b5;
523
        sizeof(*b5);
524
      }
525
    }
526
    sizeof(*b5);
527
  }
528
  sizeof(*b5);
529
}
530
extern A10 *b5;
531
 
532
A10 *b6;
533
void
534
g6 (void)
535
{
536
  sizeof(*b6);
537
  {
538
    extern A10 *b6;
539
    sizeof(*b6);
540
    {
541
      int b6;
542
      {
543
        extern IA *b6;
544
        sizeof(*b6); /* { dg-error "incomplete" } */
545
      }
546
    }
547
    sizeof(*b6);
548
  }
549
  sizeof(*b6);
550
}
551
extern A10 *b6;
552
 
553
A10 *b7;
554
void
555
g7 (void)
556
{
557
  sizeof(*b7);
558
  {
559
    extern A10 *b7;
560
    sizeof(*b7);
561
    {
562
      int b7;
563
      {
564
        extern A10 *b7;
565
        sizeof(*b7);
566
      }
567
    }
568
    sizeof(*b7);
569
  }
570
  sizeof(*b7);
571
}
572
extern A10 *b7;
573
 
574
extern IA *b8;
575
void
576
g8 (void)
577
{
578
  sizeof(*b8); /* { dg-error "incomplete" } */
579
  {
580
    extern IA *b8;
581
    sizeof(*b8); /* { dg-error "incomplete" } */
582
    {
583
      int b8;
584
      {
585
        extern IA *b8;
586
        sizeof(*b8); /* { dg-error "incomplete" } */
587
      }
588
    }
589
    sizeof(*b8); /* { dg-error "incomplete" } */
590
  }
591
  sizeof(*b8); /* { dg-error "incomplete" } */
592
}
593
extern A10 *b8;
594
 
595
extern IA *b9;
596
void
597
g9 (void)
598
{
599
  sizeof(*b9); /* { dg-error "incomplete" } */
600
  {
601
    extern IA *b9;
602
    sizeof(*b9); /* { dg-error "incomplete" } */
603
    {
604
      int b9;
605
      {
606
        extern A10 *b9;
607
        sizeof(*b9);
608
      }
609
    }
610
    sizeof(*b9); /* { dg-error "incomplete" } */
611
  }
612
  sizeof(*b9); /* { dg-error "incomplete" } */
613
}
614
extern A10 *b9;
615
 
616
extern IA *b10;
617
void
618
g10 (void)
619
{
620
  sizeof(*b10); /* { dg-error "incomplete" } */
621
  {
622
    extern A10 *b10;
623
    sizeof(*b10);
624
    {
625
      int b10;
626
      {
627
        extern IA *b10;
628
        sizeof(*b10); /* { dg-error "incomplete" } */
629
      }
630
    }
631
    sizeof(*b10);
632
  }
633
  sizeof(*b10); /* { dg-error "incomplete" } */
634
}
635
extern A10 *b10;
636
 
637
extern IA *b11;
638
void
639
g11 (void)
640
{
641
  sizeof(*b11); /* { dg-error "incomplete" } */
642
  {
643
    extern A10 *b11;
644
    sizeof(*b11);
645
    {
646
      int b11;
647
      {
648
        extern A10 *b11;
649
        sizeof(*b11);
650
      }
651
    }
652
    sizeof(*b11);
653
  }
654
  sizeof(*b11); /* { dg-error "incomplete" } */
655
}
656
extern A10 *b11;
657
 
658
extern A10 *b12;
659
void
660
g12 (void)
661
{
662
  sizeof(*b12);
663
  {
664
    extern IA *b12;
665
    sizeof(*b12);
666
    {
667
      int b12;
668
      {
669
        extern IA *b12;
670
        sizeof(*b12); /* { dg-error "incomplete" } */
671
      }
672
    }
673
    sizeof(*b12);
674
  }
675
  sizeof(*b12);
676
}
677
extern A10 *b12;
678
 
679
extern A10 *b13;
680
void
681
g13 (void)
682
{
683
  sizeof(*b13);
684
  {
685
    extern IA *b13;
686
    sizeof(*b13);
687
    {
688
      int b13;
689
      {
690
        extern A10 *b13;
691
        sizeof(*b13);
692
      }
693
    }
694
    sizeof(*b13);
695
  }
696
  sizeof(*b13);
697
}
698
extern A10 *b13;
699
 
700
extern A10 *b14;
701
void
702
g14 (void)
703
{
704
  sizeof(*b14);
705
  {
706
    extern A10 *b14;
707
    sizeof(*b14);
708
    {
709
      int b14;
710
      {
711
        extern IA *b14;
712
        sizeof(*b14); /* { dg-error "incomplete" } */
713
      }
714
    }
715
    sizeof(*b14);
716
  }
717
  sizeof(*b14);
718
}
719
extern A10 *b14;
720
 
721
extern A10 *b15;
722
void
723
g15 (void)
724
{
725
  sizeof(*b15);
726
  {
727
    extern A10 *b15;
728
    sizeof(*b15);
729
    {
730
      int b15;
731
      {
732
        extern A10 *b15;
733
        sizeof(*b15);
734
      }
735
    }
736
    sizeof(*b15);
737
  }
738
  sizeof(*b15);
739
}
740
extern A10 *b15;
741
 
742
static IA *b16;
743
void
744
g16 (void)
745
{
746
  sizeof(*b16); /* { dg-error "incomplete" } */
747
  {
748
    extern IA *b16;
749
    sizeof(*b16); /* { dg-error "incomplete" } */
750
  }
751
  sizeof(*b16); /* { dg-error "incomplete" } */
752
}
753
extern A10 *b16;
754
 
755
static IA *b17;
756
void
757
g17 (void)
758
{
759
  sizeof(*b17); /* { dg-error "incomplete" } */
760
  {
761
    extern A10 *b17;
762
    sizeof(*b17);
763
  }
764
  sizeof(*b17); /* { dg-error "incomplete" } */
765
}
766
extern A10 *b17;
767
 
768
static A10 *b18;
769
void
770
g18 (void)
771
{
772
  sizeof(*b18);
773
  {
774
    extern IA *b18;
775
    sizeof(*b18);
776
  }
777
  sizeof(*b18);
778
}
779
extern A10 *b18;
780
 
781
static A10 *b19;
782
void
783
g19 (void)
784
{
785
  sizeof(*b19);
786
  {
787
    extern A10 *b19;
788
    sizeof(*b19);
789
  }
790
  sizeof(*b19);
791
}
792
extern A10 *b19;
793
 
794
IA *c0 (void);
795
void
796
h0 (void)
797
{
798
  sizeof(*c0()); /* { dg-error "incomplete" } */
799
  {
800
    extern IA *c0 (void);
801
    sizeof(*c0()); /* { dg-error "incomplete" } */
802
    {
803
      int c0;
804
      {
805
        extern IA *c0 (void);
806
        sizeof(*c0()); /* { dg-error "incomplete" } */
807
      }
808
    }
809
    sizeof(*c0()); /* { dg-error "incomplete" } */
810
  }
811
  sizeof(*c0()); /* { dg-error "incomplete" } */
812
}
813
A10 *c0 (void) { return 0; }
814
 
815
IA *c1 (void);
816
void
817
h1 (void)
818
{
819
  sizeof(*c1()); /* { dg-error "incomplete" } */
820
  {
821
    extern IA *c1 (void);
822
    sizeof(*c1()); /* { dg-error "incomplete" } */
823
    {
824
      int c1;
825
      {
826
        extern A10 *c1 (void);
827
        sizeof(*c1());
828
      }
829
    }
830
    sizeof(*c1()); /* { dg-error "incomplete" } */
831
  }
832
  sizeof(*c1()); /* { dg-error "incomplete" } */
833
}
834
A10 *c1 (void) { return 0; }
835
 
836
IA *c2 (void);
837
void
838
h2 (void)
839
{
840
  sizeof(*c2()); /* { dg-error "incomplete" } */
841
  {
842
    extern A10 *c2 (void);
843
    sizeof(*c2());
844
    {
845
      int c2;
846
      {
847
        extern IA *c2 (void);
848
        sizeof(*c2()); /* { dg-error "incomplete" } */
849
      }
850
    }
851
    sizeof(*c2());
852
  }
853
  sizeof(*c2()); /* { dg-error "incomplete" } */
854
}
855
A10 *c2 (void) { return 0; }
856
 
857
IA *c3 (void);
858
void
859
h3 (void)
860
{
861
  sizeof(*c3()); /* { dg-error "incomplete" } */
862
  {
863
    extern A10 *c3 (void);
864
    sizeof(*c3());
865
    {
866
      int c3;
867
      {
868
        extern A10 *c3 (void);
869
        sizeof(*c3());
870
      }
871
    }
872
    sizeof(*c3());
873
  }
874
  sizeof(*c3()); /* { dg-error "incomplete" } */
875
}
876
A10 *c3 (void) { return 0; }
877
 
878
A10 *c4 (void);
879
void
880
h4 (void)
881
{
882
  sizeof(*c4());
883
  {
884
    extern IA *c4 (void);
885
    sizeof(*c4());
886
    {
887
      int c4;
888
      {
889
        extern IA *c4 (void);
890
        sizeof(*c4()); /* { dg-error "incomplete" } */
891
      }
892
    }
893
    sizeof(*c4());
894
  }
895
  sizeof(*c4());
896
}
897
A10 *c4 (void) { return 0; }
898
 
899
A10 *c5 (void);
900
void
901
h5 (void)
902
{
903
  sizeof(*c5());
904
  {
905
    extern IA *c5 (void);
906
    sizeof(*c5());
907
    {
908
      int c5;
909
      {
910
        extern A10 *c5 (void);
911
        sizeof(*c5());
912
      }
913
    }
914
    sizeof(*c5());
915
  }
916
  sizeof(*c5());
917
}
918
A10 *c5 (void) { return 0; }
919
 
920
A10 *c6 (void);
921
void
922
h6 (void)
923
{
924
  sizeof(*c6());
925
  {
926
    extern A10 *c6 (void);
927
    sizeof(*c6());
928
    {
929
      int c6;
930
      {
931
        extern IA *c6 (void);
932
        sizeof(*c6()); /* { dg-error "incomplete" } */
933
      }
934
    }
935
    sizeof(*c6());
936
  }
937
  sizeof(*c6());
938
}
939
A10 *c6 (void) { return 0; }
940
 
941
A10 *c7 (void);
942
void
943
h7 (void)
944
{
945
  sizeof(*c7());
946
  {
947
    extern A10 *c7 (void);
948
    sizeof(*c7());
949
    {
950
      int c7;
951
      {
952
        extern A10 *c7 (void);
953
        sizeof(*c7());
954
      }
955
    }
956
    sizeof(*c7());
957
  }
958
  sizeof(*c7());
959
}
960
A10 *c7 (void) { return 0; }
961
 
962
extern IA *c8 (void);
963
void
964
h8 (void)
965
{
966
  sizeof(*c8()); /* { dg-error "incomplete" } */
967
  {
968
    extern IA *c8 (void);
969
    sizeof(*c8()); /* { dg-error "incomplete" } */
970
    {
971
      int c8;
972
      {
973
        extern IA *c8 (void);
974
        sizeof(*c8()); /* { dg-error "incomplete" } */
975
      }
976
    }
977
    sizeof(*c8()); /* { dg-error "incomplete" } */
978
  }
979
  sizeof(*c8()); /* { dg-error "incomplete" } */
980
}
981
extern A10 *c8 (void) { return 0; }
982
 
983
extern IA *c9 (void);
984
void
985
h9 (void)
986
{
987
  sizeof(*c9()); /* { dg-error "incomplete" } */
988
  {
989
    extern IA *c9 (void);
990
    sizeof(*c9()); /* { dg-error "incomplete" } */
991
    {
992
      int c9;
993
      {
994
        extern A10 *c9 (void);
995
        sizeof(*c9());
996
      }
997
    }
998
    sizeof(*c9()); /* { dg-error "incomplete" } */
999
  }
1000
  sizeof(*c9()); /* { dg-error "incomplete" } */
1001
}
1002
extern A10 *c9 (void) { return 0; }
1003
 
1004
extern IA *c10 (void);
1005
void
1006
h10 (void)
1007
{
1008
  sizeof(*c10()); /* { dg-error "incomplete" } */
1009
  {
1010
    extern A10 *c10 (void);
1011
    sizeof(*c10());
1012
    {
1013
      int c10;
1014
      {
1015
        extern IA *c10 (void);
1016
        sizeof(*c10()); /* { dg-error "incomplete" } */
1017
      }
1018
    }
1019
    sizeof(*c10());
1020
  }
1021
  sizeof(*c10()); /* { dg-error "incomplete" } */
1022
}
1023
extern A10 *c10 (void) { return 0; }
1024
 
1025
extern IA *c11 (void);
1026
void
1027
h11 (void)
1028
{
1029
  sizeof(*c11()); /* { dg-error "incomplete" } */
1030
  {
1031
    extern A10 *c11 (void);
1032
    sizeof(*c11());
1033
    {
1034
      int c11;
1035
      {
1036
        extern A10 *c11 (void);
1037
        sizeof(*c11());
1038
      }
1039
    }
1040
    sizeof(*c11());
1041
  }
1042
  sizeof(*c11()); /* { dg-error "incomplete" } */
1043
}
1044
extern A10 *c11 (void) { return 0; }
1045
 
1046
extern A10 *c12 (void);
1047
void
1048
h12 (void)
1049
{
1050
  sizeof(*c12());
1051
  {
1052
    extern IA *c12 (void);
1053
    sizeof(*c12());
1054
    {
1055
      int c12;
1056
      {
1057
        extern IA *c12 (void);
1058
        sizeof(*c12()); /* { dg-error "incomplete" } */
1059
      }
1060
    }
1061
    sizeof(*c12());
1062
  }
1063
  sizeof(*c12());
1064
}
1065
extern A10 *c12 (void) { return 0; }
1066
 
1067
extern A10 *c13 (void);
1068
void
1069
h13 (void)
1070
{
1071
  sizeof(*c13());
1072
  {
1073
    extern IA *c13 (void);
1074
    sizeof(*c13());
1075
    {
1076
      int c13;
1077
      {
1078
        extern A10 *c13 (void);
1079
        sizeof(*c13());
1080
      }
1081
    }
1082
    sizeof(*c13());
1083
  }
1084
  sizeof(*c13());
1085
}
1086
extern A10 *c13 (void) { return 0; }
1087
 
1088
extern A10 *c14 (void);
1089
void
1090
h14 (void)
1091
{
1092
  sizeof(*c14());
1093
  {
1094
    extern A10 *c14 (void);
1095
    sizeof(*c14());
1096
    {
1097
      int c14;
1098
      {
1099
        extern IA *c14 (void);
1100
        sizeof(*c14()); /* { dg-error "incomplete" } */
1101
      }
1102
    }
1103
    sizeof(*c14());
1104
  }
1105
  sizeof(*c14());
1106
}
1107
extern A10 *c14 (void) { return 0; }
1108
 
1109
extern A10 *c15 (void);
1110
void
1111
h15 (void)
1112
{
1113
  sizeof(*c15());
1114
  {
1115
    extern A10 *c15 (void);
1116
    sizeof(*c15());
1117
    {
1118
      int c15;
1119
      {
1120
        extern A10 *c15 (void);
1121
        sizeof(*c15());
1122
      }
1123
    }
1124
    sizeof(*c15());
1125
  }
1126
  sizeof(*c15());
1127
}
1128
extern A10 *c15 (void) { return 0; }
1129
 
1130
static IA *c16 (void);
1131
void
1132
h16 (void)
1133
{
1134
  sizeof(*c16()); /* { dg-error "incomplete" } */
1135
  {
1136
    extern IA *c16 (void);
1137
    sizeof(*c16()); /* { dg-error "incomplete" } */
1138
  }
1139
  sizeof(*c16()); /* { dg-error "incomplete" } */
1140
}
1141
static A10 *c16 (void) { return 0; }
1142
 
1143
static IA *c17 (void);
1144
void
1145
h17 (void)
1146
{
1147
  sizeof(*c17()); /* { dg-error "incomplete" } */
1148
  {
1149
    extern A10 *c17 (void);
1150
    sizeof(*c17());
1151
  }
1152
  sizeof(*c17()); /* { dg-error "incomplete" } */
1153
}
1154
static A10 *c17 (void) { return 0; }
1155
 
1156
static A10 *c18 (void);
1157
void
1158
h18 (void)
1159
{
1160
  sizeof(*c18());
1161
  {
1162
    extern IA *c18 (void);
1163
    sizeof(*c18());
1164
  }
1165
  sizeof(*c18());
1166
}
1167
static A10 *c18 (void) { return 0; }
1168
 
1169
static A10 *c19 (void);
1170
void
1171
h19 (void)
1172
{
1173
  sizeof(*c19());
1174
  {
1175
    extern A10 *c19 (void);
1176
    sizeof(*c19());
1177
  }
1178
  sizeof(*c19());
1179
}
1180
static A10 *c19 (void) { return 0; }

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.