array-init.c revision 09865a903affa9c08687859d8de65470064c7bc2 
1// RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s
2
3extern int foof() = 1; // expected-error{{illegal initializer (only variables can be initialized)}}
4
5static int x, y, z;
6
7static int ary[] = { x, y, z }; // expected-error{{initializer element is not a compile-time constant}}
8int ary2[] = { x, y, z }; // expected-error{{initializer element is not a compile-time constant}}
9
10extern int fileScopeExtern[3] = { 1, 3, 5 }; // expected-warning{{'extern' variable has an initializer}}
11
12static long ary3[] = { 1, "abc", 3, 4 }; // expected-warning{{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char [4]'}}
13
14void 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
54void 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
73void 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
98void 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
107unsigned char asso_values[] = { 34 };
108int legal2() {
109  return asso_values[0];
110}
111
112void 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
133typedef int AryT[];
134
135void 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
142static char const xx[] = "test";
143int xx_sizecheck[(sizeof(xx) / sizeof(char)) == 5? 1 : -1];
144static char const yy[5] = "test";
145static char const zz[3] = "test"; // expected-warning{{initializer-string for char array is too long}}
146
147void 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
168void 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
175float r1[10] = {{7}}; //expected-warning{{braces around scalar initializer}}
176float r2[] = {{8}}; //expected-warning{{braces around scalar initializer}}
177char r3[][5] = {1,2,3,4,5,6};
178int r3_sizecheck[(sizeof(r3) / sizeof(char[5])) == 2? 1 : -1];
179char r3_2[sizeof r3 == 10 ? 1 : -1];
180float r4[1][2] = {1,{2},3,4}; //expected-warning{{braces around scalar initializer}} expected-warning{{excess elements in array initializer}}
181char r5[][5] = {"aa", "bbb", "ccccc"};
182char r6[sizeof r5 == 15 ? 1 : -1];
183const char r7[] = "zxcv";
184char r8[5] = "5char";
185char r9[5] = "6chars"; //expected-warning{{initializer-string for char array is too long}}
186
187int r11[0] = {}; //expected-warning{{zero size arrays are an extension}} expected-warning{{use of GNU empty initializer extension}}
188
189// Some struct tests
190void autoStructTest() {
191struct s1 {char a; char b;} t1;
192struct s2 {struct s1 c;} t2 = { t1 };
193// The following is a less than great diagnostic (though it's on par with EDG).
194struct s1 t3[] = {t1, t1, "abc", 0}; //expected-warning{{incompatible pointer to integer conversion initializing 'char' with an expression of type 'char [4]'}}
195int t4[sizeof t3 == 6 ? 1 : -1];
196}
197struct foo { int z; } w;
198int bar (void) {
199  struct foo z = { w }; //expected-error{{initializing 'int' with an expression of incompatible type 'struct foo'}}
200  return z.z;
201}
202struct s3 {void (*a)(void);} t5 = {autoStructTest};
203struct {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}}
205union {char a; int b;} t7[] = {1, 2, 3};
206int t8[sizeof t7 == (3*sizeof(int)) ? 1 : -1];
207
208struct bittest{int : 31, a, :21, :12, b;};
209struct bittest bittestvar = {1, 2, 3, 4}; //expected-warning{{excess elements in struct initializer}}
210
211// Not completely sure what should happen here...
212int u1 = {}; //expected-warning{{use of GNU empty initializer extension}} expected-error{{scalar initializer cannot be empty}}
213int u2 = {{3}}; //expected-warning{{too many braces around scalar initializer}}
214
215// PR2362
216void varArray() {
217  int c[][x] = { 0 }; //expected-error{{variable-sized object may not be initialized}}
218}
219
220// PR2151
221void 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
224void noNamedInit() {
225  struct {int:5;} x[] = {6}; //expected-error{{initializer for aggregate with no elements}}
226}
227struct {int a; int:5;} noNamedImplicit[] = {1,2,3};
228int noNamedImplicitCheck[sizeof(noNamedImplicit) == 3 * sizeof(*noNamedImplicit) ? 1 : -1];
229
230
231// ptrs are constant
232struct soft_segment_descriptor {
233  long ssd_base;
234};
235static int dblfault_tss;
236
237union uniao { int ola; } xpto[1];
238
239struct soft_segment_descriptor gdt_segs[] = {
240  {(long) &dblfault_tss},
241  { (long)xpto},
242};
243
244static void sppp_ipv6cp_up();
245const 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
248struct _Matrix { union { float m[4][4]; }; }; //expected-warning{{anonymous unions are a GNU extension in C}}
249typedef struct _Matrix Matrix;
250void 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
266char badchararray[1] = { badchararray[0], "asdf" }; // expected-warning {{excess elements in array initializer}} expected-error {{initializer element is not a compile-time constant}}
267