URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [testsuite/] [gcc.dg/] [redecl-3.c] - Blame information for rev 298

Details | Compare with Previous | View Log


/* Test for multiple declarations and composite types.  Includes bug
   13801.  */
/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
/* { dg-do compile } */
/* { dg-options "-g" } */
 
typedef int IA[];
typedef int A10[10];
 
/* Test all combinations of: a variable declared at file scope (no
   type specifiers, or extern, or static), or just inside a function
   (with extern), redeclared in an inner scope (with extern), and
   redeclared in an inner scope when the previous declaration is
   hidden (with extern, and not if the original declaration was
   static).  Test three times: incomplete variable types; pointers to
   incomplete types; functions returning such pointers.  */
 
IA a0;
void
f0 (void)
{
  sizeof(a0); /* { dg-error "incomplete" } */
  {
    extern IA a0;
    sizeof(a0); /* { dg-error "incomplete" } */
    {
      int a0;
      {
        extern IA a0;
        sizeof(a0); /* { dg-error "incomplete" } */
      }
    }
    sizeof(a0); /* { dg-error "incomplete" } */
  }
  sizeof(a0); /* { dg-error "incomplete" } */
}
extern A10 a0;
 
IA a1;
void
f1 (void)
{
  sizeof(a1); /* { dg-error "incomplete" } */
  {
    extern IA a1;
    sizeof(a1); /* { dg-error "incomplete" } */
    {
      int a1;
      {
        extern A10 a1;
        sizeof(a1);
      }
    }
    sizeof(a1); /* { dg-error "incomplete" } */
  }
  sizeof(a1); /* { dg-error "incomplete" } */
}
extern A10 a1;
 
IA a2;
void
f2 (void)
{
  sizeof(a2); /* { dg-error "incomplete" } */
  {
    extern A10 a2;
    sizeof(a2);
    {
      int a2;
      {
        extern IA a2;
        sizeof(a2); /* { dg-error "incomplete" } */
      }
    }
    sizeof(a2);
  }
  sizeof(a2); /* { dg-error "incomplete" } */
}
extern A10 a2;
 
IA a3;
void
f3 (void)
{
  sizeof(a3); /* { dg-error "incomplete" } */
  {
    extern A10 a3;
    sizeof(a3);
    {
      int a3;
      {
        extern A10 a3;
        sizeof(a3);
      }
    }
    sizeof(a3);
  }
  sizeof(a3); /* { dg-error "incomplete" } */
}
extern A10 a3;
 
A10 a4;
void
f4 (void)
{
  sizeof(a4);
  {
    extern IA a4;
    sizeof(a4);
    {
      int a4;
      {
        extern IA a4;
        sizeof(a4); /* { dg-error "incomplete" } */
      }
    }
    sizeof(a4);
  }
  sizeof(a4);
}
extern A10 a4;
 
A10 a5;
void
f5 (void)
{
  sizeof(a5);
  {
    extern IA a5;
    sizeof(a5);
    {
      int a5;
      {
        extern A10 a5;
        sizeof(a5);
      }
    }
    sizeof(a5);
  }
  sizeof(a5);
}
extern A10 a5;
 
A10 a6;
void
f6 (void)
{
  sizeof(a6);
  {
    extern A10 a6;
    sizeof(a6);
    {
      int a6;
      {
        extern IA a6;
        sizeof(a6); /* { dg-error "incomplete" } */
      }
    }
    sizeof(a6);
  }
  sizeof(a6);
}
extern A10 a6;
 
A10 a7;
void
f7 (void)
{
  sizeof(a7);
  {
    extern A10 a7;
    sizeof(a7);
    {
      int a7;
      {
        extern A10 a7;
        sizeof(a7);
      }
    }
    sizeof(a7);
  }
  sizeof(a7);
}
extern A10 a7;
 
extern IA a8;
void
f8 (void)
{
  sizeof(a8); /* { dg-error "incomplete" } */
  {
    extern IA a8;
    sizeof(a8); /* { dg-error "incomplete" } */
    {
      int a8;
      {
        extern IA a8;
        sizeof(a8); /* { dg-error "incomplete" } */
      }
    }
    sizeof(a8); /* { dg-error "incomplete" } */
  }
  sizeof(a8); /* { dg-error "incomplete" } */
}
extern A10 a8;
 
extern IA a9;
void
f9 (void)
{
  sizeof(a9); /* { dg-error "incomplete" } */
  {
    extern IA a9;
    sizeof(a9); /* { dg-error "incomplete" } */
    {
      int a9;
      {
        extern A10 a9;
        sizeof(a9);
      }
    }
    sizeof(a9); /* { dg-error "incomplete" } */
  }
  sizeof(a9); /* { dg-error "incomplete" } */
}
extern A10 a9;
 
extern IA a10;
void
f10 (void)
{
  sizeof(a10); /* { dg-error "incomplete" } */
  {
    extern A10 a10;
    sizeof(a10);
    {
      int a10;
      {
        extern IA a10;
        sizeof(a10); /* { dg-error "incomplete" } */
      }
    }
    sizeof(a10);
  }
  sizeof(a10); /* { dg-error "incomplete" } */
}
extern A10 a10;
 
extern IA a11;
void
f11 (void)
{
  sizeof(a11); /* { dg-error "incomplete" } */
  {
    extern A10 a11;
    sizeof(a11);
    {
      int a11;
      {
        extern A10 a11;
        sizeof(a11);
      }
    }
    sizeof(a11);
  }
  sizeof(a11); /* { dg-error "incomplete" } */
}
extern A10 a11;
 
extern A10 a12;
void
f12 (void)
{
  sizeof(a12);
  {
    extern IA a12;
    sizeof(a12);
    {
      int a12;
      {
        extern IA a12;
        sizeof(a12); /* { dg-error "incomplete" } */
      }
    }
    sizeof(a12);
  }
  sizeof(a12);
}
extern A10 a12;
 
extern A10 a13;
void
f13 (void)
{
  sizeof(a13);
  {
    extern IA a13;
    sizeof(a13);
    {
      int a13;
      {
        extern A10 a13;
        sizeof(a13);
      }
    }
    sizeof(a13);
  }
  sizeof(a13);
}
extern A10 a13;
 
extern A10 a14;
void
f14 (void)
{
  sizeof(a14);
  {
    extern A10 a14;
    sizeof(a14);
    {
      int a14;
      {
        extern IA a14;
        sizeof(a14); /* { dg-error "incomplete" } */
      }
    }
    sizeof(a14);
  }
  sizeof(a14);
}
extern A10 a14;
 
extern A10 a15;
void
f15 (void)
{
  sizeof(a15);
  {
    extern A10 a15;
    sizeof(a15);
    {
      int a15;
      {
        extern A10 a15;
        sizeof(a15);
      }
    }
    sizeof(a15);
  }
  sizeof(a15);
}
extern A10 a15;
 
static IA a16;
void
f16 (void)
{
  sizeof(a16); /* { dg-error "incomplete" } */
  {
    extern IA a16;
    sizeof(a16); /* { dg-error "incomplete" } */
  }
  sizeof(a16); /* { dg-error "incomplete" } */
}
extern A10 a16;
 
static IA a17;
void
f17 (void)
{
  sizeof(a17); /* { dg-error "incomplete" } */
  {
    extern A10 a17;
    sizeof(a17);
  }
  sizeof(a17); /* { dg-error "incomplete" } */
}
extern A10 a17;
 
static A10 a18;
void
f18 (void)
{
  sizeof(a18);
  {
    extern IA a18;
    sizeof(a18);
  }
  sizeof(a18);
}
extern A10 a18;
 
static A10 a19;
void
f19 (void)
{
  sizeof(a19);
  {
    extern A10 a19;
    sizeof(a19);
  }
  sizeof(a19);
}
extern A10 a19;
 
IA *b0;
void
g0 (void)
{
  sizeof(*b0); /* { dg-error "incomplete" } */
  {
    extern IA *b0;
    sizeof(*b0); /* { dg-error "incomplete" } */
    {
      int b0;
      {
        extern IA *b0;
        sizeof(*b0); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*b0); /* { dg-error "incomplete" } */
  }
  sizeof(*b0); /* { dg-error "incomplete" } */
}
extern A10 *b0;
 
IA *b1;
void
g1 (void)
{
  sizeof(*b1); /* { dg-error "incomplete" } */
  {
    extern IA *b1;
    sizeof(*b1); /* { dg-error "incomplete" } */
    {
      int b1;
      {
        extern A10 *b1;
        sizeof(*b1);
      }
    }
    sizeof(*b1); /* { dg-error "incomplete" } */
  }
  sizeof(*b1); /* { dg-error "incomplete" } */
}
extern A10 *b1;
 
IA *b2;
void
g2 (void)
{
  sizeof(*b2); /* { dg-error "incomplete" } */
  {
    extern A10 *b2;
    sizeof(*b2);
    {
      int b2;
      {
        extern IA *b2;
        sizeof(*b2); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*b2);
  }
  sizeof(*b2); /* { dg-error "incomplete" } */
}
extern A10 *b2;
 
IA *b3;
void
g3 (void)
{
  sizeof(*b3); /* { dg-error "incomplete" } */
  {
    extern A10 *b3;
    sizeof(*b3);
    {
      int b3;
      {
        extern A10 *b3;
        sizeof(*b3);
      }
    }
    sizeof(*b3);
  }
  sizeof(*b3); /* { dg-error "incomplete" } */
}
extern A10 *b3;
 
A10 *b4;
void
g4 (void)
{
  sizeof(*b4);
  {
    extern IA *b4;
    sizeof(*b4);
    {
      int b4;
      {
        extern IA *b4;
        sizeof(*b4); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*b4);
  }
  sizeof(*b4);
}
extern A10 *b4;
 
A10 *b5;
void
g5 (void)
{
  sizeof(*b5);
  {
    extern IA *b5;
    sizeof(*b5);
    {
      int b5;
      {
        extern A10 *b5;
        sizeof(*b5);
      }
    }
    sizeof(*b5);
  }
  sizeof(*b5);
}
extern A10 *b5;
 
A10 *b6;
void
g6 (void)
{
  sizeof(*b6);
  {
    extern A10 *b6;
    sizeof(*b6);
    {
      int b6;
      {
        extern IA *b6;
        sizeof(*b6); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*b6);
  }
  sizeof(*b6);
}
extern A10 *b6;
 
A10 *b7;
void
g7 (void)
{
  sizeof(*b7);
  {
    extern A10 *b7;
    sizeof(*b7);
    {
      int b7;
      {
        extern A10 *b7;
        sizeof(*b7);
      }
    }
    sizeof(*b7);
  }
  sizeof(*b7);
}
extern A10 *b7;
 
extern IA *b8;
void
g8 (void)
{
  sizeof(*b8); /* { dg-error "incomplete" } */
  {
    extern IA *b8;
    sizeof(*b8); /* { dg-error "incomplete" } */
    {
      int b8;
      {
        extern IA *b8;
        sizeof(*b8); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*b8); /* { dg-error "incomplete" } */
  }
  sizeof(*b8); /* { dg-error "incomplete" } */
}
extern A10 *b8;
 
extern IA *b9;
void
g9 (void)
{
  sizeof(*b9); /* { dg-error "incomplete" } */
  {
    extern IA *b9;
    sizeof(*b9); /* { dg-error "incomplete" } */
    {
      int b9;
      {
        extern A10 *b9;
        sizeof(*b9);
      }
    }
    sizeof(*b9); /* { dg-error "incomplete" } */
  }
  sizeof(*b9); /* { dg-error "incomplete" } */
}
extern A10 *b9;
 
extern IA *b10;
void
g10 (void)
{
  sizeof(*b10); /* { dg-error "incomplete" } */
  {
    extern A10 *b10;
    sizeof(*b10);
    {
      int b10;
      {
        extern IA *b10;
        sizeof(*b10); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*b10);
  }
  sizeof(*b10); /* { dg-error "incomplete" } */
}
extern A10 *b10;
 
extern IA *b11;
void
g11 (void)
{
  sizeof(*b11); /* { dg-error "incomplete" } */
  {
    extern A10 *b11;
    sizeof(*b11);
    {
      int b11;
      {
        extern A10 *b11;
        sizeof(*b11);
      }
    }
    sizeof(*b11);
  }
  sizeof(*b11); /* { dg-error "incomplete" } */
}
extern A10 *b11;
 
extern A10 *b12;
void
g12 (void)
{
  sizeof(*b12);
  {
    extern IA *b12;
    sizeof(*b12);
    {
      int b12;
      {
        extern IA *b12;
        sizeof(*b12); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*b12);
  }
  sizeof(*b12);
}
extern A10 *b12;
 
extern A10 *b13;
void
g13 (void)
{
  sizeof(*b13);
  {
    extern IA *b13;
    sizeof(*b13);
    {
      int b13;
      {
        extern A10 *b13;
        sizeof(*b13);
      }
    }
    sizeof(*b13);
  }
  sizeof(*b13);
}
extern A10 *b13;
 
extern A10 *b14;
void
g14 (void)
{
  sizeof(*b14);
  {
    extern A10 *b14;
    sizeof(*b14);
    {
      int b14;
      {
        extern IA *b14;
        sizeof(*b14); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*b14);
  }
  sizeof(*b14);
}
extern A10 *b14;
 
extern A10 *b15;
void
g15 (void)
{
  sizeof(*b15);
  {
    extern A10 *b15;
    sizeof(*b15);
    {
      int b15;
      {
        extern A10 *b15;
        sizeof(*b15);
      }
    }
    sizeof(*b15);
  }
  sizeof(*b15);
}
extern A10 *b15;
 
static IA *b16;
void
g16 (void)
{
  sizeof(*b16); /* { dg-error "incomplete" } */
  {
    extern IA *b16;
    sizeof(*b16); /* { dg-error "incomplete" } */
  }
  sizeof(*b16); /* { dg-error "incomplete" } */
}
extern A10 *b16;
 
static IA *b17;
void
g17 (void)
{
  sizeof(*b17); /* { dg-error "incomplete" } */
  {
    extern A10 *b17;
    sizeof(*b17);
  }
  sizeof(*b17); /* { dg-error "incomplete" } */
}
extern A10 *b17;
 
static A10 *b18;
void
g18 (void)
{
  sizeof(*b18);
  {
    extern IA *b18;
    sizeof(*b18);
  }
  sizeof(*b18);
}
extern A10 *b18;
 
static A10 *b19;
void
g19 (void)
{
  sizeof(*b19);
  {
    extern A10 *b19;
    sizeof(*b19);
  }
  sizeof(*b19);
}
extern A10 *b19;
 
IA *c0 (void);
void
h0 (void)
{
  sizeof(*c0()); /* { dg-error "incomplete" } */
  {
    extern IA *c0 (void);
    sizeof(*c0()); /* { dg-error "incomplete" } */
    {
      int c0;
      {
        extern IA *c0 (void);
        sizeof(*c0()); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*c0()); /* { dg-error "incomplete" } */
  }
  sizeof(*c0()); /* { dg-error "incomplete" } */
}
A10 *c0 (void) { return 0; }
 
IA *c1 (void);
void
h1 (void)
{
  sizeof(*c1()); /* { dg-error "incomplete" } */
  {
    extern IA *c1 (void);
    sizeof(*c1()); /* { dg-error "incomplete" } */
    {
      int c1;
      {
        extern A10 *c1 (void);
        sizeof(*c1());
      }
    }
    sizeof(*c1()); /* { dg-error "incomplete" } */
  }
  sizeof(*c1()); /* { dg-error "incomplete" } */
}
A10 *c1 (void) { return 0; }
 
IA *c2 (void);
void
h2 (void)
{
  sizeof(*c2()); /* { dg-error "incomplete" } */
  {
    extern A10 *c2 (void);
    sizeof(*c2());
    {
      int c2;
      {
        extern IA *c2 (void);
        sizeof(*c2()); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*c2());
  }
  sizeof(*c2()); /* { dg-error "incomplete" } */
}
A10 *c2 (void) { return 0; }
 
IA *c3 (void);
void
h3 (void)
{
  sizeof(*c3()); /* { dg-error "incomplete" } */
  {
    extern A10 *c3 (void);
    sizeof(*c3());
    {
      int c3;
      {
        extern A10 *c3 (void);
        sizeof(*c3());
      }
    }
    sizeof(*c3());
  }
  sizeof(*c3()); /* { dg-error "incomplete" } */
}
A10 *c3 (void) { return 0; }
 
A10 *c4 (void);
void
h4 (void)
{
  sizeof(*c4());
  {
    extern IA *c4 (void);
    sizeof(*c4());
    {
      int c4;
      {
        extern IA *c4 (void);
        sizeof(*c4()); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*c4());
  }
  sizeof(*c4());
}
A10 *c4 (void) { return 0; }
 
A10 *c5 (void);
void
h5 (void)
{
  sizeof(*c5());
  {
    extern IA *c5 (void);
    sizeof(*c5());
    {
      int c5;
      {
        extern A10 *c5 (void);
        sizeof(*c5());
      }
    }
    sizeof(*c5());
  }
  sizeof(*c5());
}
A10 *c5 (void) { return 0; }
 
A10 *c6 (void);
void
h6 (void)
{
  sizeof(*c6());
  {
    extern A10 *c6 (void);
    sizeof(*c6());
    {
      int c6;
      {
        extern IA *c6 (void);
        sizeof(*c6()); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*c6());
  }
  sizeof(*c6());
}
A10 *c6 (void) { return 0; }
 
A10 *c7 (void);
void
h7 (void)
{
  sizeof(*c7());
  {
    extern A10 *c7 (void);
    sizeof(*c7());
    {
      int c7;
      {
        extern A10 *c7 (void);
        sizeof(*c7());
      }
    }
    sizeof(*c7());
  }
  sizeof(*c7());
}
A10 *c7 (void) { return 0; }
 
extern IA *c8 (void);
void
h8 (void)
{
  sizeof(*c8()); /* { dg-error "incomplete" } */
  {
    extern IA *c8 (void);
    sizeof(*c8()); /* { dg-error "incomplete" } */
    {
      int c8;
      {
        extern IA *c8 (void);
        sizeof(*c8()); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*c8()); /* { dg-error "incomplete" } */
  }
  sizeof(*c8()); /* { dg-error "incomplete" } */
}
extern A10 *c8 (void) { return 0; }
 
extern IA *c9 (void);
void
h9 (void)
{
  sizeof(*c9()); /* { dg-error "incomplete" } */
  {
    extern IA *c9 (void);
    sizeof(*c9()); /* { dg-error "incomplete" } */
    {
      int c9;
      {
        extern A10 *c9 (void);
        sizeof(*c9());
      }
    }
    sizeof(*c9()); /* { dg-error "incomplete" } */
  }
  sizeof(*c9()); /* { dg-error "incomplete" } */
}
extern A10 *c9 (void) { return 0; }
 
extern IA *c10 (void);
void
h10 (void)
{
  sizeof(*c10()); /* { dg-error "incomplete" } */
  {
    extern A10 *c10 (void);
    sizeof(*c10());
    {
      int c10;
      {
        extern IA *c10 (void);
        sizeof(*c10()); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*c10());
  }
  sizeof(*c10()); /* { dg-error "incomplete" } */
}
extern A10 *c10 (void) { return 0; }
 
extern IA *c11 (void);
void
h11 (void)
{
  sizeof(*c11()); /* { dg-error "incomplete" } */
  {
    extern A10 *c11 (void);
    sizeof(*c11());
    {
      int c11;
      {
        extern A10 *c11 (void);
        sizeof(*c11());
      }
    }
    sizeof(*c11());
  }
  sizeof(*c11()); /* { dg-error "incomplete" } */
}
extern A10 *c11 (void) { return 0; }
 
extern A10 *c12 (void);
void
h12 (void)
{
  sizeof(*c12());
  {
    extern IA *c12 (void);
    sizeof(*c12());
    {
      int c12;
      {
        extern IA *c12 (void);
        sizeof(*c12()); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*c12());
  }
  sizeof(*c12());
}
extern A10 *c12 (void) { return 0; }
 
extern A10 *c13 (void);
void
h13 (void)
{
  sizeof(*c13());
  {
    extern IA *c13 (void);
    sizeof(*c13());
    {
      int c13;
      {
        extern A10 *c13 (void);
        sizeof(*c13());
      }
    }
    sizeof(*c13());
  }
  sizeof(*c13());
}
extern A10 *c13 (void) { return 0; }
 
extern A10 *c14 (void);
void
h14 (void)
{
  sizeof(*c14());
  {
    extern A10 *c14 (void);
    sizeof(*c14());
    {
      int c14;
      {
        extern IA *c14 (void);
        sizeof(*c14()); /* { dg-error "incomplete" } */
      }
    }
    sizeof(*c14());
  }
  sizeof(*c14());
}
extern A10 *c14 (void) { return 0; }
 
extern A10 *c15 (void);
void
h15 (void)
{
  sizeof(*c15());
  {
    extern A10 *c15 (void);
    sizeof(*c15());
    {
      int c15;
      {
        extern A10 *c15 (void);
        sizeof(*c15());
      }
    }
    sizeof(*c15());
  }
  sizeof(*c15());
}
extern A10 *c15 (void) { return 0; }
 
static IA *c16 (void);
void
h16 (void)
{
  sizeof(*c16()); /* { dg-error "incomplete" } */
  {
    extern IA *c16 (void);
    sizeof(*c16()); /* { dg-error "incomplete" } */
  }
  sizeof(*c16()); /* { dg-error "incomplete" } */
}
static A10 *c16 (void) { return 0; }
 
static IA *c17 (void);
void
h17 (void)
{
  sizeof(*c17()); /* { dg-error "incomplete" } */
  {
    extern A10 *c17 (void);
    sizeof(*c17());
  }
  sizeof(*c17()); /* { dg-error "incomplete" } */
}
static A10 *c17 (void) { return 0; }
 
static A10 *c18 (void);
void
h18 (void)
{
  sizeof(*c18());
  {
    extern IA *c18 (void);
    sizeof(*c18());
  }
  sizeof(*c18());
}
static A10 *c18 (void) { return 0; }
 
static A10 *c19 (void);
void
h19 (void)
{
  sizeof(*c19());
  {
    extern A10 *c19 (void);
    sizeof(*c19());
  }
  sizeof(*c19());
}
static A10 *c19 (void) { return 0; }

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [testsuite/] [gcc.dg/] [redecl-3.c] - Blame information for rev 298

Line No.	Rev	Author	Line
1	298	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; }`