gcc/testsuite/gcc.dg/redecl-3.c

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