Clang Project

clang_source_code/test/Sema/switch.c
1// RUN: %clang_cc1 -fsyntax-only -verify -Wswitch-enum -Wcovered-switch-default -triple x86_64-linux-gnu %s
2void f (int z) { 
3  while (z) { 
4    default: z--;            // expected-error {{statement not in switch}}
5  } 
6}
7
8void foo(int X) {
9  switch (X) {
10  case 42: ;                 // expected-note {{previous case}}
11  case 5000000000LL:         // expected-warning {{overflow}}
12  case 42:                   // expected-error {{duplicate case value '42'}}
13   ;
14
15  case 100 ... 99: ;         // expected-warning {{empty case range}}
16
17  case 43: ;                 // expected-note {{previous case}}
18  case 43 ... 45:  ;         // expected-error {{duplicate case value}}
19
20  case 100 ... 20000:;       // expected-note {{previous case}}
21  case 15000 ... 40000000:;  // expected-error {{duplicate case value}}
22  }
23}
24
25void test3(void) { 
26  // empty switch;
27  switch (0); // expected-warning {{no case matching constant switch condition '0'}} \
28              // expected-warning {{switch statement has empty body}} \
29              // expected-note{{put the semicolon on a separate line to silence this warning}}
30}
31
32extern int g();
33
34void test4()
35{
36  int cond;
37  switch (cond) {
38  case 0 && g():
39  case 1 || g():
40    break;
41  }
42
43  switch(cond)  {
44  case g(): // expected-error {{expression is not an integer constant expression}}
45  case 0 ... g(): // expected-error {{expression is not an integer constant expression}}
46    break;
47  }
48  
49  switch (cond) {
50  case 0 && g() ... 1 || g():
51    break;
52  }
53  
54  switch (cond) {
55  case g() // expected-error {{expression is not an integer constant expression}}
56      && 0:
57    break;
58  }
59  
60  switch (cond) {
61  case 0 ...
62      g() // expected-error {{expression is not an integer constant expression}}
63      || 1:
64    break;
65  }
66}
67
68void test5(int z) { 
69  switch(z) {
70    default:  // expected-note {{previous case defined here}}
71    default:  // expected-error {{multiple default labels in one switch}}
72      break;
73  }
74} 
75
76void test6() {
77  char ch = 'a';
78  switch(ch) {
79    case 1234:  // expected-warning {{overflow converting case value}}
80      break;
81  }
82}
83
84// PR5606
85int f0(int var) {
86  switch (va) { // expected-error{{use of undeclared identifier 'va'}}
87  case 1:
88    break;
89  case 2:
90    return 1;
91  }
92  return 2;
93}
94
95void test7() {
96  enum {
97    A = 1,
98    B
99  } a;
100  switch(a) { //expected-warning{{enumeration value 'B' not handled in switch}}
101    case A:
102      break;
103  }
104  switch(a) {
105    case B:
106    case A:
107      break;
108  }
109  switch(a) {
110    case A:
111    case B:
112    case 3: // expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
113      break;
114  }
115  switch(a) {
116    case A:
117    case B:
118    case 3 ... //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
119        4: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
120      break;
121  }
122  switch(a) {
123    case 1 ... 2:
124      break;
125  }
126  switch(a) {
127    case 0 ... 2: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
128      break;
129  }
130  switch(a) {
131    case 1 ... 3: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
132      break;
133  }
134  switch(a) {
135    case 0 ...  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
136      3:  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
137      break;
138  }
139
140}
141
142void test8() {
143  enum {
144    A,
145    B,
146    C = 1
147  } a;
148  switch(a) {
149    case A:
150    case B:
151     break;
152  }
153  switch(a) {
154    case A:
155    case C:
156      break;
157  }
158  switch(a) { //expected-warning{{enumeration value 'B' not handled in switch}}
159    case A:
160      break;
161  }
162}
163
164void test9() {
165  enum {
166    A = 3,
167    C = 1
168  } a;
169  switch(a) {
170    case 0: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
171    case 1:
172    case 2: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
173    case 3:
174    case 4: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
175      break;
176  }
177}
178
179void test10() {
180  enum {
181    A = 10,
182    C = 2,
183    B = 4,
184    D = 12
185  } a;
186  switch(a) {
187    case 0 ...  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
188     1:  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
189    case 2 ... 4:
190    case 5 ...  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
191       9:  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
192    case 10 ... 12:
193    case 13 ...  //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
194              16: //expected-warning{{case value not in enumerated type 'enum (anonymous enum}}
195      break;
196  }
197}
198
199void test11() {
200  enum {
201    A = -1,
202    B,
203    C
204  } a;
205  switch(a) { //expected-warning{{enumeration value 'A' not handled in switch}}
206    case B:
207    case C:
208      break;
209  }
210
211  switch(a) { //expected-warning{{enumeration value 'A' not explicitly handled in switch}}
212    case B:
213    case C:
214      break;
215      
216    default:
217      break;
218  }
219}
220
221void test12() {
222  enum {
223    A = -1,
224    B = 4294967286
225  } a;
226  switch(a) {
227    case A:
228    case B:
229      break;
230  }
231}
232
233// <rdar://problem/7643909>
234typedef enum {
235    val1,
236    val2,
237    val3
238} my_type_t;
239
240int test13(my_type_t t) {
241  switch(t) { // expected-warning{{enumeration value 'val3' not handled in switch}}
242  case val1:
243    return 1;
244  case val2:
245    return 2;
246  }
247  return -1;
248}
249
250// <rdar://problem/7658121>
251enum {
252  EC0 = 0xFFFF0000,
253  EC1 = 0xFFFF0001,
254};
255
256int test14(int a) {
257  switch(a) {
258  case EC0: return 0;
259  case EC1: return 1;
260  }
261  return 0;
262}
263
264void f1(unsigned x) {
265  switch (x) {
266  case -1: break;
267  default: break;
268  }
269}
270
271void test15() {
272  int i = 0;
273  switch (1) { // expected-warning {{no case matching constant switch condition '1'}}
274  case 0: i = 0; break;
275  case 2: i++; break;
276  }
277}
278
279void test16() {
280  const char c = '5';
281  switch (c) { // expected-warning {{no case matching constant switch condition '53'}}
282  case '6': return;
283  }
284}
285
286// PR7359
287void test17(int x) {
288  switch (x >= 17) { // expected-warning {{switch condition has boolean value}}
289  case 0: return;
290  }
291
292  switch ((int) (x <= 17)) {
293  case 0: return;
294  }
295}
296
297int test18() {
298  enum { A, B } a;
299  switch (a) {
300  case A: return 0;
301  case B: return 1;
302  case 7: return 1; // expected-warning {{case value not in enumerated type}}
303  default: return 2; // expected-warning {{default label in switch which covers all enumeration values}}
304  }
305}
306
307// rdar://110822110
308typedef enum {
309        kOne = 1,
310} Ints;
311        
312void rdar110822110(Ints i)
313{
314        switch (i) {
315                case kOne:
316                        break;
317                case 2:  // expected-warning {{case value not in enumerated type 'Ints'}}          
318                        break;
319                default: // expected-warning {{default label in switch which covers all enumeration values}}
320                        break;
321                }
322}
323
324// PR9243
325#define TEST19MACRO 5
326void test19(int i) {
327  enum {
328    kTest19Enum1 = 7,
329    kTest19Enum2 = kTest19Enum1
330  };
331  const int a = 3;
332  switch (i) {
333    case 5: // expected-note {{previous case}}
334    case TEST19MACRO: // expected-error {{duplicate case value '5'}}
335
336    case 7: // expected-note {{previous case}}
337    case kTest19Enum1: // expected-error {{duplicate case value: '7' and 'kTest19Enum1' both equal '7'}} \
338                       // expected-note {{previous case}}
339    case kTest19Enum1: // expected-error {{duplicate case value 'kTest19Enum1'}} \
340                       // expected-note {{previous case}}
341    case kTest19Enum2: // expected-error {{duplicate case value: 'kTest19Enum1' and 'kTest19Enum2' both equal '7'}} \
342                       // expected-note {{previous case}}
343    case (int)kTest19Enum2: //expected-error {{duplicate case value 'kTest19Enum2'}}
344
345    case 3: // expected-note {{previous case}}
346    case a: // expected-error {{duplicate case value: '3' and 'a' both equal '3'}} \
347            // expected-note {{previous case}}
348    case a: // expected-error {{duplicate case value 'a'}}
349      break;
350  }
351}
352
353// Allow the warning 'case value not in enumerated type' to be silenced with
354// the following pattern.
355//
356// If 'case' expression refers to a static const variable of the correct enum
357// type, then we count this as a sufficient declaration of intent by the user,
358// so we silence the warning.
359enum ExtendedEnum1 {
360  EE1_a,
361  EE1_b
362};
363
364enum ExtendedEnum1_unrelated { EE1_misc };
365
366static const enum ExtendedEnum1 EE1_c = 100;
367static const enum ExtendedEnum1_unrelated EE1_d = 101;
368
369void switch_on_ExtendedEnum1(enum ExtendedEnum1 e) {
370  switch(e) {
371  case EE1_a: break;
372  case EE1_b: break;
373  case EE1_c: break; // no-warning
374  case EE1_d: break; // expected-warning {{case value not in enumerated type 'enum ExtendedEnum1'}}
375  // expected-warning@-1 {{comparison of two values with different enumeration types in switch statement ('enum ExtendedEnum1' and 'enum ExtendedEnum1_unrelated')}}
376  }
377}
378
379void PR11778(char c, int n, long long ll) {
380  // Do not reject this; we don't have duplicate case values because we
381  // check for duplicates in the promoted type.
382  switch (c) case 1: case 257: ; // expected-warning {{overflow}}
383
384  switch (n) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}}
385  switch ((int)ll) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}}
386  switch ((long long)n) case 0x100000001LL: case 1: ;
387  switch (ll) case 0x100000001LL: case 1: ;
388}
389
CodeThinker, Enjoy your reading code