1 /* 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
f0(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
f1(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
f2(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
f3(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
f4(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
f5(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
f6(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
f7(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
f8(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
f9(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
f10(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
f11(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
f12(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
f13(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
f14(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
f15(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
f16(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
f17(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
f18(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
f19(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
g0(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
g1(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
g2(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
g3(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
g4(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
g5(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
g6(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
g7(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
g8(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
g9(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
g10(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
g11(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
g12(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
g13(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
g14(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
g15(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
g16(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
g17(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
g18(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
g19(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
h0(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 }
c0(void)813 A10 *c0 (void) { return 0; }
814 
815 IA *c1 (void);
816 void
h1(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 }
c1(void)834 A10 *c1 (void) { return 0; }
835 
836 IA *c2 (void);
837 void
h2(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 }
c2(void)855 A10 *c2 (void) { return 0; }
856 
857 IA *c3 (void);
858 void
h3(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 }
c3(void)876 A10 *c3 (void) { return 0; }
877 
878 A10 *c4 (void);
879 void
h4(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 }
c4(void)897 A10 *c4 (void) { return 0; }
898 
899 A10 *c5 (void);
900 void
h5(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 }
c5(void)918 A10 *c5 (void) { return 0; }
919 
920 A10 *c6 (void);
921 void
h6(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 }
c6(void)939 A10 *c6 (void) { return 0; }
940 
941 A10 *c7 (void);
942 void
h7(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 }
c7(void)960 A10 *c7 (void) { return 0; }
961 
962 extern IA *c8 (void);
963 void
h8(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 }
c8(void)981 extern A10 *c8 (void) { return 0; }
982 
983 extern IA *c9 (void);
984 void
h9(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 }
c9(void)1002 extern A10 *c9 (void) { return 0; }
1003 
1004 extern IA *c10 (void);
1005 void
h10(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 }
c10(void)1023 extern A10 *c10 (void) { return 0; }
1024 
1025 extern IA *c11 (void);
1026 void
h11(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 }
c11(void)1044 extern A10 *c11 (void) { return 0; }
1045 
1046 extern A10 *c12 (void);
1047 void
h12(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 }
c12(void)1065 extern A10 *c12 (void) { return 0; }
1066 
1067 extern A10 *c13 (void);
1068 void
h13(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 }
c13(void)1086 extern A10 *c13 (void) { return 0; }
1087 
1088 extern A10 *c14 (void);
1089 void
h14(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 }
c14(void)1107 extern A10 *c14 (void) { return 0; }
1108 
1109 extern A10 *c15 (void);
1110 void
h15(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 }
c15(void)1128 extern A10 *c15 (void) { return 0; }
1129 
1130 static IA *c16 (void);
1131 void
h16(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 }
c16(void)1141 static A10 *c16 (void) { return 0; }
1142 
1143 static IA *c17 (void);
1144 void
h17(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 }
c17(void)1154 static A10 *c17 (void) { return 0; }
1155 
1156 static A10 *c18 (void);
1157 void
h18(void)1158 h18 (void)
1159 {
1160   sizeof(*c18());
1161   {
1162     extern IA *c18 (void);
1163     sizeof(*c18());
1164   }
1165   sizeof(*c18());
1166 }
c18(void)1167 static A10 *c18 (void) { return 0; }
1168 
1169 static A10 *c19 (void);
1170 void
h19(void)1171 h19 (void)
1172 {
1173   sizeof(*c19());
1174   {
1175     extern A10 *c19 (void);
1176     sizeof(*c19());
1177   }
1178   sizeof(*c19());
1179 }
c19(void)1180 static A10 *c19 (void) { return 0; }
1181