test/Sema/array-init.c

   1 // RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s
   2
   3 extern int foof() = 1; // expected-error{{illegal initializer (only variables can be initialized)}}
   4
   5 static int x, y, z;
   6
   7 static int ary[] = { x, y, z }; // expected-error{{initializer element is not a compile-time constant}}
   8 int ary2[] = { x, y, z }; // expected-error{{initializer element is not a compile-time constant}}
   9
  10 extern int fileScopeExtern[3] = { 1, 3, 5 }; // expected-warning{{'extern' variable has an initializer}}
  11
  12 static long ary3[] = { 1, "abc", 3, 4 }; // expected-warning{{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char [4]'}}
  13
  14 void func() {
  15   int x = 1;
  16
  17   typedef int TInt = 1; // expected-error{{illegal initializer (only variables can be initialized)}}
  18
  19   int xComputeSize[] = { 1, 3, 5 };
  20
  21   int x3[x] = { 1, 2 }; // expected-error{{variable-sized object may not be initialized}}
  22
  23   int x4 = { 1, 2 }; // expected-warning{{excess elements in scalar initializer}}
  24
  25   int y[4][3] = {
  26     { 1, 3, 5 },
  27     { 2, 4, 6 },
  28     { 3, 5, 7 },
  29   };
  30
  31   int y2[4][3] = {
  32     1, 3, 5, 2, 4, 6, 3, 5, 7
  33   };
  34
  35   int y3[4][3] = {
  36     { 1, 3, 5 },
  37     { 2, 4, 6 },
  38     { 3, 5, 7 },
  39     { 4, 6, 8 },
  40     { 5 }, // expected-warning{{excess elements in array initializer}}
  41   };
  42
  43   struct threeElements {
  44     int a,b,c;
  45   } z = { 1 };
  46
  47   struct threeElements *p = 7; // expected-warning{{incompatible integer to pointer conversion initializing 'struct threeElements *' with an expression of type 'int'}}
  48
  49   extern int blockScopeExtern[3] = { 1, 3, 5 }; // expected-error{{'extern' variable cannot have an initializer}}
  50
  51   static long x2[3] = { 1.0, "abc" , 5.8 }; // expected-warning{{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char [4]'}}
  52 }
  53
  54 void test() {
  55   int y1[3] = {
  56     { 1, 2, 3 } // expected-warning{{braces around scalar initializer}} expected-warning{{excess elements in scalar initializer}}
  57   };
  58   int y3[4][3] = {
  59     { 1, 3, 5 },
  60     { 2, 4, 6 },
  61     { 3, 5, 7 },
  62     { 4, 6, 8 },
  63     {  }, // expected-warning{{use of GNU empty initializer extension}} expected-warning{{excess elements in array initializer}}
  64   };
  65   int y4[4][3] = {
  66     { 1, 3, 5, 2 }, // expected-warning{{excess elements in array initializer}}
  67     { 4, 6 },
  68     { 3, 5, 7 },
  69     { 4, 6, 8 },
  70   };
  71 }
  72
  73 void allLegalAndSynonymous() {
  74   short q[4][3][2] = {
  75     { 1 },
  76     { 2, 3 },
  77     { 4, 5, 6 }
  78   };
  79   short q2[4][3][2] = {
  80     { 1, 0, 0, 0, 0, 0 },
  81     { 2, 3, 0, 0, 0, 0 },
  82     { 4, 5, 6 }
  83   };
  84   short q3[4][3][2] = {
  85     {
  86       { 1 },
  87     },
  88     {
  89       { 2, 3 },
  90     },
  91     {
  92       { 4, 5 },
  93       { 6 },
  94     },
  95   };
  96 }
  97
  98 void legal() {
  99   short q[][3][2] = {
 100     { 1 },
 101     { 2, 3 },
 102     { 4, 5, 6 }
 103   };
 104   int q_sizecheck[(sizeof(q) / sizeof(short [3][2])) == 3? 1 : -1];
 105 }
 106
 107 unsigned char asso_values[] = { 34 };
 108 int legal2() {
 109   return asso_values[0];
 110 }
 111
 112 void illegal() {
 113   short q2[4][][2] = { // expected-error{{array has incomplete element type 'short [][2]'}}
 114     { 1, 0, 0, 0, 0, 0 },
 115     { 2, 3, 0, 0, 0, 0 },
 116     { 4, 5, 6 }
 117   };
 118   short q3[4][3][] = { // expected-error{{array has incomplete element type 'short []'}}
 119     {
 120       { 1 },
 121     },
 122     {
 123       { 2, 3 },
 124     },
 125     {
 126       { 4, 5 },
 127       { 6 },
 128     },
 129   };
 130   int a[][] = { 1, 2 }; // expected-error{{array has incomplete element type 'int []'}}
 131 }
 132
 133 typedef int AryT[];
 134
 135 void testTypedef()
 136 {
 137   AryT a = { 1, 2 }, b = { 3, 4, 5 };
 138   int a_sizecheck[(sizeof(a) / sizeof(int)) == 2? 1 : -1];
 139   int b_sizecheck[(sizeof(b) / sizeof(int)) == 3? 1 : -1];
 140 }
 141
 142 static char const xx[] = "test";
 143 int xx_sizecheck[(sizeof(xx) / sizeof(char)) == 5? 1 : -1];
 144 static char const yy[5] = "test";
 145 static char const zz[3] = "test"; // expected-warning{{initializer-string for char array is too long}}
 146
 147 void charArrays() {
 148   static char const test[] = "test";
 149   int test_sizecheck[(sizeof(test) / sizeof(char)) == 5? 1 : -1];
 150   static char const test2[] = { "weird stuff" };
 151   static char const test3[] = { "test", "excess stuff" }; // expected-warning{{excess elements in char array initializer}}
 152
 153   char* cp[] = { "Hello" };
 154
 155   char c[] = { "Hello" };
 156   int l[sizeof(c) == 6 ? 1 : -1];
 157
 158   int i[] = { "Hello "}; // expected-warning{{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char [7]'}}
 159   char c2[] = { "Hello", "Good bye" }; //expected-warning{{excess elements in char array initializer}}
 160
 161   int i2[1] = { "Hello" }; //expected-warning{{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char [6]'}}
 162   char c3[5] = { "Hello" };
 163   char c4[4] = { "Hello" }; //expected-warning{{initializer-string for char array is too long}}
 164
 165   int i3[] = {}; //expected-warning{{zero size arrays are an extension}} expected-warning{{use of GNU empty initializer extension}}
 166 }
 167
 168 void variableArrayInit() {
 169   int a = 4;
 170   char strlit[a] = "foo"; //expected-error{{array initializer must be an initializer list or string literal}}
 171   int b[a] = { 1, 2, 4 }; //expected-error{{variable-sized object may not be initialized}}
 172 }
 173
 174 // Pure array tests
 175 float r1[10] = {{7}}; //expected-warning{{braces around scalar initializer}}
 176 float r2[] = {{8}}; //expected-warning{{braces around scalar initializer}}
 177 char r3[][5] = {1,2,3,4,5,6};
 178 int r3_sizecheck[(sizeof(r3) / sizeof(char[5])) == 2? 1 : -1];
 179 char r3_2[sizeof r3 == 10 ? 1 : -1];
 180 float r4[1][2] = {1,{2},3,4}; //expected-warning{{braces around scalar initializer}} expected-warning{{excess elements in array initializer}}
 181 char r5[][5] = {"aa", "bbb", "ccccc"};
 182 char r6[sizeof r5 == 15 ? 1 : -1];
 183 const char r7[] = "zxcv";
 184 char r8[5] = "5char";
 185 char r9[5] = "6chars"; //expected-warning{{initializer-string for char array is too long}}
 186
 187 int r11[0] = {}; //expected-warning{{zero size arrays are an extension}} expected-warning{{use of GNU empty initializer extension}}
 188
 189 // Some struct tests
 190 void autoStructTest() {
 191 struct s1 {char a; char b;} t1;
 192 struct s2 {struct s1 c;} t2 = { t1 };
 193 // The following is a less than great diagnostic (though it's on par with EDG).
 194 struct s1 t3[] = {t1, t1, "abc", 0}; //expected-warning{{incompatible pointer to integer conversion initializing 'char' with an expression of type 'char [4]'}}
 195 int t4[sizeof t3 == 6 ? 1 : -1];
 196 }
 197 struct foo { int z; } w;
 198 int bar (void) {
 199   struct foo z = { w }; //expected-error{{initializing 'int' with an expression of incompatible type 'struct foo'}}
 200   return z.z;
 201 }
 202 struct s3 {void (*a)(void);} t5 = {autoStructTest};
 203 struct {int a; int b[];} t6 = {1, {1, 2, 3}}; // expected-warning{{flexible array initialization is a GNU extension}} \
 204 // expected-note{{initialized flexible array member 'b' is here}}
 205 union {char a; int b;} t7[] = {1, 2, 3};
 206 int t8[sizeof t7 == (3*sizeof(int)) ? 1 : -1];
 207
 208 struct bittest{int : 31, a, :21, :12, b;};
 209 struct bittest bittestvar = {1, 2, 3, 4}; //expected-warning{{excess elements in struct initializer}}
 210
 211 // Not completely sure what should happen here...
 212 int u1 = {}; //expected-warning{{use of GNU empty initializer extension}} expected-error{{scalar initializer cannot be empty}}
 213 int u2 = {{3}}; //expected-warning{{too many braces around scalar initializer}}
 214
 215 // PR2362
 216 void varArray() {
 217   int c[][x] = { 0 }; //expected-error{{variable-sized object may not be initialized}}
 218 }
 219
 220 // PR2151
 221 void emptyInit() {struct {} x[] = {6};} //expected-warning{{empty struct (accepted as an extension) has size 0 in C, size 1 in C++}} \
 222 // expected-error{{initializer for aggregate with no elements}}
 223
 224 void noNamedInit() {
 225   struct {int:5;} x[] = {6}; //expected-error{{initializer for aggregate with no elements}}
 226 }
 227 struct {int a; int:5;} noNamedImplicit[] = {1,2,3};
 228 int noNamedImplicitCheck[sizeof(noNamedImplicit) == 3 * sizeof(*noNamedImplicit) ? 1 : -1];
 229
 230
 231 // ptrs are constant
 232 struct soft_segment_descriptor {
 233   long ssd_base;
 234 };
 235 static int dblfault_tss;
 236
 237 union uniao { int ola; } xpto[1];
 238
 239 struct soft_segment_descriptor gdt_segs[] = {
 240   {(long) &dblfault_tss},
 241   { (long)xpto},
 242 };
 243
 244 static void sppp_ipv6cp_up();
 245 const struct {} ipcp = { sppp_ipv6cp_up }; //expected-warning{{empty struct (accepted as an extension) has size 0 in C, size 1 in C++}} \
 246 // expected-warning{{excess elements in struct initializer}}
 247
 248 struct _Matrix { union { float m[4][4]; }; }; //expected-warning{{anonymous unions are a GNU extension in C}}
 249 typedef struct _Matrix Matrix;
 250 void test_matrix() {
 251   const Matrix mat1 = {
 252     { { 1.0f, 2.0f, 3.0f, 4.0f,
 253         5.0f, 6.0f, 7.0f, 8.0f,
 254         9.0f, 10.0f, 11.0f, 12.0f,
 255         13.0f, 14.0f, 15.0f, 16.0f } }
 256   };
 257
 258   const Matrix mat2 = {
 259     1.0f, 2.0f, 3.0f, 4.0f,
 260     5.0f, 6.0f, 7.0f, 8.0f,
 261     9.0f, 10.0f, 11.0f, 12.0f,
 262     13.0f, 14.0f, 15.0f, 16.0f
 263   };
 264 }
 265
 266 char badchararray[1] = { badchararray[0], "asdf" }; // expected-warning {{excess elements in array initializer}} expected-error {{initializer element is not a compile-time constant}}