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
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; }