Home | History | Annotate | Download | only in Sema 
      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{{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}}
    267 
    268 // Test the GNU extension for initializing an array from an array
    269 // compound literal. PR9261.
    270 typedef int int5[5];
    271 int a1[5] = (int[]){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int [5]' from a compound literal of type 'int [5]' is a GNU extension}}
    272 int a2[5] = (int[5]){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int [5]' from a compound literal of type 'int [5]' is a GNU extension}}
    273 int a3[] = ((int[]){1, 2, 3, 4, 5}); // expected-warning{{initialization of an array of type 'int []' from a compound literal of type 'int [5]' is a GNU extension}}
    274 int a4[] = (int[5]){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int []' from a compound literal of type 'int [5]' is a GNU extension}}
    275 int a5[] = (int5){1, 2, 3, 4, 5}; // expected-warning{{initialization of an array of type 'int []' from a compound literal of type 'int5' (aka 'int [5]') is a GNU extension}}
    276 
    277 int a6[5] = (int[]){1, 2, 3}; // expected-error{{cannot initialize array of type 'int [5]' with array of type 'int [3]'}}
    278 
    279 int nonconst_value();
    280 int a7[5] = (int[5]){ 1, 2, 3, 4, nonconst_value() }; // expected-error{{initializer element is not a compile-time constant}}
    281