2009-12-16 04:14:24 +08:00
// RUN: %clang_cc1 -fsyntax-only -verify %s
2007-07-24 01:05:23 +08:00
void f ( int z ) {
while ( z ) {
2007-08-24 02:29:20 +08:00
default : z - - ; // expected-error {{statement not in switch}}
2007-07-24 01:05:23 +08:00
}
}
2007-08-23 13:46:52 +08:00
void foo ( int X ) {
switch ( X ) {
2008-11-24 07:12:31 +08:00
case 42 : ; // expected-note {{previous case}}
2007-08-24 02:29:20 +08:00
case 5000000000LL : // expected-warning {{overflow}}
case 42 : // expected-error {{duplicate case value}}
2007-08-23 13:46:52 +08:00
;
2007-08-24 01:48:14 +08:00
2007-08-24 02:29:20 +08:00
case 100 . . . 99 : ; // expected-warning {{empty case range}}
2008-11-24 07:12:31 +08:00
case 43 : ; // expected-note {{previous case}}
2007-08-24 02:29:20 +08:00
case 43 . . . 45 : ; // expected-error {{duplicate case value}}
2008-11-24 07:12:31 +08:00
case 100 . . . 20000 : ; // expected-note {{previous case}}
2007-08-24 02:29:20 +08:00
case 15000 . . . 40000000 : ; // expected-error {{duplicate case value}}
2007-08-23 13:46:52 +08:00
}
}
2007-08-23 22:29:07 +08:00
void test3 ( void ) {
2007-08-24 02:29:20 +08:00
// empty switch;
2010-05-18 11:19:21 +08:00
switch ( 0 ) ; // expected-warning {{no case matching constant switch condition '0'}}
2007-08-23 22:29:07 +08:00
}
2008-11-23 05:04:56 +08:00
extern int g ( ) ;
void test4 ( )
{
2010-05-18 11:19:21 +08:00
int cond ;
switch ( cond ) {
2008-11-23 05:04:56 +08:00
case 0 & & g ( ) :
case 1 | | g ( ) :
break ;
}
2010-05-18 11:19:21 +08:00
switch ( cond ) {
2008-12-01 10:13:02 +08:00
case g ( ) : / / expected - error { { expression is not an integer constant expression } }
case 0 . . . g ( ) : // expected-error {{expression is not an integer constant expression}}
2008-11-23 05:04:56 +08:00
break ;
}
2010-05-18 11:19:21 +08:00
switch ( cond ) {
2008-11-23 05:04:56 +08:00
case 0 & & g ( ) . . . 1 | | g ( ) :
break ;
}
2008-11-23 05:50:49 +08:00
2010-05-18 11:19:21 +08:00
switch ( cond ) {
2011-12-10 06:58:01 +08:00
case g ( ) & & 0 : / / expected - error { { expression is not an integer constant expression } } // expected-note {{subexpression not valid in a constant expression}}
2008-11-23 05:50:49 +08:00
break ;
}
2010-05-18 11:19:21 +08:00
switch ( cond ) {
2011-12-10 06:58:01 +08:00
case 0 . . . g ( ) | | 1 : // expected-error {{expression is not an integer constant expression}} // expected-note {{subexpression not valid in a constant expression}}
2008-11-23 05:50:49 +08:00
break ;
}
2008-11-23 05:04:56 +08:00
}
2008-11-24 07:12:31 +08:00
void test5 ( int z ) {
switch ( z ) {
default : // expected-note {{previous case defined here}}
default : // expected-error {{multiple default labels in one switch}}
break ;
}
}
2009-10-17 00:45:22 +08:00
void test6 ( ) {
2010-05-18 11:19:21 +08:00
char ch = ' a ' ;
2009-10-17 00:45:22 +08:00
switch ( ch ) {
case 1234 : // expected-warning {{overflow converting case value}}
break ;
}
}
2009-11-25 14:20:02 +08:00
// PR5606
2010-10-15 04:34:08 +08:00
int f0 ( int var ) {
2009-11-25 14:20:02 +08:00
switch ( va ) { // expected-error{{use of undeclared identifier 'va'}}
case 1 :
break ;
case 2 :
return 1 ;
}
return 2 ;
}
2010-02-09 06:24:16 +08:00
void test7 ( ) {
enum {
A = 1 ,
B
} a ;
switch ( a ) { //expected-warning{{enumeration value 'B' not handled in switch}}
case A :
break ;
}
switch ( a ) {
case B :
case A :
break ;
}
switch ( a ) {
case A :
case B :
case 3 : // expected-warning{{case value not in enumerated type ''}}
break ;
}
switch ( a ) {
case A :
case B :
case 3 . . . //expected-warning{{case value not in enumerated type ''}}
4 : //expected-warning{{case value not in enumerated type ''}}
break ;
}
switch ( a ) {
case 1 . . . 2 :
break ;
}
switch ( a ) {
case 0 . . . 2 : //expected-warning{{case value not in enumerated type ''}}
break ;
}
switch ( a ) {
case 1 . . . 3 : //expected-warning{{case value not in enumerated type ''}}
break ;
}
switch ( a ) {
case 0 . . . //expected-warning{{case value not in enumerated type ''}}
3 : //expected-warning{{case value not in enumerated type ''}}
break ;
}
}
void test8 ( ) {
enum {
A ,
B ,
C = 1
} a ;
switch ( a ) {
case A :
case B :
break ;
}
switch ( a ) {
case A :
case C :
break ;
}
switch ( a ) { //expected-warning{{enumeration value 'B' not handled in switch}}
case A :
break ;
}
}
void test9 ( ) {
enum {
A = 3 ,
C = 1
} a ;
switch ( a ) {
case 0 : //expected-warning{{case value not in enumerated type ''}}
case 1 :
case 2 : //expected-warning{{case value not in enumerated type ''}}
case 3 :
case 4 : //expected-warning{{case value not in enumerated type ''}}
break ;
}
}
void test10 ( ) {
enum {
A = 10 ,
C = 2 ,
B = 4 ,
D = 12
} a ;
switch ( a ) {
case 0 . . . //expected-warning{{case value not in enumerated type ''}}
1 : //expected-warning{{case value not in enumerated type ''}}
case 2 . . . 4 :
case 5 . . . //expected-warning{{case value not in enumerated type ''}}
9 : //expected-warning{{case value not in enumerated type ''}}
case 10 . . . 12 :
case 13 . . . //expected-warning{{case value not in enumerated type ''}}
16 : //expected-warning{{case value not in enumerated type ''}}
break ;
}
}
void test11 ( ) {
enum {
A = - 1 ,
B ,
C
} a ;
switch ( a ) { //expected-warning{{enumeration value 'A' not handled in switch}}
case B :
case C :
break ;
}
switch ( a ) {
case B :
case C :
break ;
default :
break ;
}
}
void test12 ( ) {
enum {
A = - 1 ,
B = 4294967286
} a ;
switch ( a ) {
case A :
case B :
break ;
}
}
2010-02-18 07:29:11 +08:00
// <rdar://problem/7643909>
typedef enum {
val1 ,
val2 ,
val3
} my_type_t ;
int test13 ( my_type_t t ) {
switch ( t ) { // expected-warning{{enumeration value 'val3' not handled in switch}}
case val1 :
return 1 ;
case val2 :
return 2 ;
}
return - 1 ;
}
2010-02-18 08:56:01 +08:00
// <rdar://problem/7658121>
enum {
EC0 = 0xFFFF0000 ,
EC1 = 0xFFFF0001 ,
} ;
int test14 ( int a ) {
switch ( a ) {
case EC0 : return 0 ;
case EC1 : return 1 ;
}
return 0 ;
}
2010-03-01 09:04:55 +08:00
void f1 ( unsigned x ) {
switch ( x ) {
case - 1 : break ;
default : break ;
}
}
2010-05-18 11:19:21 +08:00
void test15 ( ) {
int i = 0 ;
switch ( 1 ) { // expected-warning {{no case matching constant switch condition '1'}}
case 0 : i = 0 ; break ;
case 2 : i + + ; break ;
}
}
void test16 ( ) {
const char c = ' 5 ' ;
switch ( c ) { // expected-warning {{no case matching constant switch condition '53'}}
case ' 6 ' : return ;
}
}
2010-06-12 09:56:02 +08:00
// PR7359
void test17 ( int x ) {
switch ( x > = 17 ) { // expected-warning {{switch condition has boolean value}}
case 0 : return ;
}
switch ( ( int ) ( x < = 17 ) ) {
case 0 : return ;
}
}
2012-01-22 02:12:07 +08:00
int test18 ( ) {
enum { A , B } a ;
switch ( a ) {
case A : return 0 ;
case B : return 1 ;
default : return 2 ; // expected-warning {{default is unreachable as all enumeration values are accounted for}}
}
}