git.gag.com Git - debian/cc1111/blob - support/valdiag/tests/constantRange.c

   1 #include <stdint.h>
   2
   3 volatile int8_t c;
   4
   5 /* sorry about the uggly source,
   6    but this way it can be the same as in the regression tests */
   7 #define ASSERT(x) c = (x)
   8
   9  int8_t s8;
  10 uint8_t u8;
  11
  12  int16_t s16;
  13 uint16_t u16;
  14
  15  int32_t s32;
  16 uint32_t u32;
  17
  18 #ifdef TEST1
  19 void foo(void)
  20 {
  21   ASSERT (! (INT8_MIN - 1 == s8));              /* WARNING */
  22   ASSERT (! (INT8_MAX + 1 == s8));              /* WARNING */
  23   ASSERT (  (INT8_MIN - 1 != s8));              /* WARNING */
  24   ASSERT (  (INT8_MAX + 1 != s8));              /* WARNING */
  25   ASSERT (  (INT8_MIN - 1 <  s8));              /* WARNING */
  26   ASSERT (! (INT8_MAX     <  s8));              /* WARNING */
  27   ASSERT (  (INT8_MIN     <= s8));              /* WARNING */
  28   ASSERT (! (INT8_MAX + 1 <= s8));              /* WARNING */
  29   ASSERT (! (INT8_MIN     >  s8));              /* WARNING */
  30   ASSERT (  (INT8_MAX + 1 >  s8));              /* WARNING */
  31   ASSERT (! (INT8_MIN - 1 >= s8));              /* WARNING */
  32   ASSERT (  (INT8_MAX     >= s8));              /* WARNING */
  33
  34   ASSERT (! (        0 - 1 == u8));             /* WARNING */
  35   ASSERT (! (UINT8_MAX + 1 == u8));             /* WARNING */
  36   ASSERT (  (        0 - 1 != u8));             /* WARNING */
  37   ASSERT (  (UINT8_MAX + 1 != u8));             /* WARNING */
  38   ASSERT (  (        0 - 1 <  u8));             /* WARNING */
  39   ASSERT (! (UINT8_MAX     <  u8));             /* WARNING */
  40   ASSERT (  (        0     <= u8));             /* WARNING */
  41   ASSERT (! (UINT8_MAX + 1 <= u8));             /* WARNING */
  42   ASSERT (! (        0     >  u8));             /* WARNING */
  43   ASSERT (  (UINT8_MAX + 1 >  u8));             /* WARNING */
  44   ASSERT (! (        0 - 1 >= u8));             /* WARNING */
  45   ASSERT (  (UINT8_MAX     >= u8));             /* WARNING */
  46
  47   /* force extension to long to avoid int (16 bit) overflow */
  48   ASSERT (! (INT16_MIN - 1L == s16));           /* WARNING */
  49   ASSERT (! (INT16_MAX + 1L == s16));           /* WARNING */
  50   ASSERT (  (INT16_MIN - 1L != s16));           /* WARNING */
  51   ASSERT (  (INT16_MAX + 1L != s16));           /* WARNING */
  52   ASSERT (  (INT16_MIN - 1L <  s16));           /* WARNING */
  53   ASSERT (! (INT16_MAX      <  s16));           /* WARNING */
  54   ASSERT (  (INT16_MIN      <= s16));           /* WARNING */
  55   ASSERT (! (INT16_MAX + 1L <= s16));           /* WARNING */
  56   ASSERT (! (INT16_MIN      >  s16));           /* WARNING */
  57   ASSERT (  (INT16_MAX + 1L >  s16));           /* WARNING */
  58   ASSERT (! (INT16_MIN - 1L >= s16));           /* WARNING */
  59   ASSERT (  (INT16_MAX      >= s16));           /* WARNING */
  60
  61   ASSERT (! (         0 - 1L == u16));          /* WARNING */
  62   ASSERT (! (UINT16_MAX + 1L == u16));          /* WARNING */
  63   ASSERT (  (         0 - 1L != u16));          /* WARNING */
  64   ASSERT (  (UINT16_MAX + 1L != u16));          /* WARNING */
  65   ASSERT (  (         0 - 1L <  u16));          /* WARNING */
  66   ASSERT (! (UINT16_MAX      <  u16));          /* WARNING */
  67   ASSERT (  (         0      <= u16));          /* WARNING */
  68   ASSERT (! (UINT16_MAX + 1L <= u16));          /* WARNING */
  69   ASSERT (! (         0      >  u16));          /* WARNING */
  70   ASSERT (  (UINT16_MAX + 1L >  u16));          /* WARNING */
  71   ASSERT (! (         0 - 1L >= u16));          /* WARNING */
  72   ASSERT (  (UINT16_MAX      >= u16));          /* WARNING */
  73
  74    /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1),
  75       there's no 'double' or 'long long' */
  76 /* ASSERT (! (INT32_MIN - 1 == s32)); */
  77 /* ASSERT (! (INT32_MAX + 1 == s32)); */
  78 /* ASSERT (  (INT32_MIN - 1 != s32)); */
  79 /* ASSERT (  (INT32_MAX + 1 != s32)); */
  80 /* ASSERT (  (INT32_MIN - 1 <  s32)); */
  81    ASSERT (! (INT32_MAX     <  s32));           /* WARNING(SDCC) */
  82    ASSERT (  (INT32_MIN     <= s32));           /* WARNING(SDCC) */
  83 /* ASSERT (! (INT32_MAX + 1 <= s32)); */
  84    ASSERT (! (INT32_MIN     >  s32));           /* WARNING(SDCC) */
  85 /* ASSERT (  (INT32_MAX + 1 >  s32)); */
  86 /* ASSERT (! (INT32_MIN - 1 >= s32)); */
  87    ASSERT (  (INT32_MAX     >= s32));           /* WARNING(SDCC) */
  88
  89    /* (0 - 1) wraps around to UINT32_MAX -> untestable */
  90 /* ASSERT (! (         0 - 1 == u32)); */
  91 /* ASSERT (! (UINT32_MAX + 1 == u32)); */
  92 /* ASSERT (  (         0 - 1 != u32)); */
  93 /* ASSERT (  (UINT32_MAX + 1 != u32)); */
  94 /* ASSERT (  (         0 - 1 <  u32)); */
  95    ASSERT (! (UINT32_MAX     <  u32));          /* WARNING(SDCC) */
  96    ASSERT (  (         0     <= u32));          /* WARNING(SDCC) */
  97 /* ASSERT (! (UINT32_MAX + 1 <= u32)); */
  98    ASSERT (! (         0     >  u32));          /* WARNING(SDCC) */
  99 /* ASSERT (  (UINT32_MAX + 1 >  u32)); */
 100 /* ASSERT (! (         0 - 1 >= u32)); */
 101    ASSERT (  (UINT32_MAX     >= u32));          /* WARNING(SDCC) */
 102 }
 103 #endif
 104
 105 #ifdef TEST2
 106 void foo(void)
 107 {
 108    s8 = -129;           /* WARNING */
 109    s8 =  INT8_MIN;
 110    s8 = UINT8_MAX;
 111    s8 =  256;           /* WARNING */
 112
 113    s8 = -129;           /* WARNING */
 114    u8 =  INT8_MIN;
 115    u8 = UINT8_MAX;
 116    u8 =  256;           /* WARNING */
 117
 118    s16 = -32769L;       /* WARNING */
 119    s16 =  INT16_MIN;
 120    s16 = UINT16_MAX;
 121    s16 =  65536L;       /* WARNING */
 122
 123    s16 = -32769L;       /* WARNING */
 124    u16 =  INT16_MIN;
 125    u16 = UINT16_MAX;
 126    u16 =  65536L;       /* WARNING */
 127
 128    /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1),
 129       there's no 'double' or 'long long' */
 130    s32 =  INT32_MIN;
 131    s32 = UINT32_MAX;
 132
 133    u32 =  INT32_MIN;
 134    u32 = UINT32_MAX;
 135 }
 136 #endif
 137
 138 #ifdef TEST3
 139 #include <stdbool.h>
 140
 141 void foo(void)
 142 {
 143 #if defined(PORT_HOST)
 144    volatile bool sb, ub;
 145 #else
 146    volatile   signed bool sb;
 147    volatile unsigned bool ub;
 148 #endif
 149
 150   sb = -2;
 151   sb = -1;
 152   sb =  0;
 153   sb =  1;
 154
 155   ub = -1;
 156   ub =  0;
 157   ub =  1;
 158   ub =  2;
 159
 160   ASSERT (! (-2 == sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 161   ASSERT (  (-1 == sb));
 162   ASSERT (  ( 0 == sb));
 163   ASSERT (! ( 1 == sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 164
 165   ASSERT (  (-2 != sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 166   ASSERT (  (-1 != sb));
 167   ASSERT (  ( 0 != sb));
 168   ASSERT (  ( 1 != sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 169
 170   ASSERT (  (-2 <  sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 171   ASSERT (  (-1 <  sb));
 172   ASSERT (! ( 0 <  sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 173
 174   ASSERT (  (-1 <= sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 175   ASSERT (  ( 0 <= sb));
 176   ASSERT (! ( 1 <= sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 177
 178   ASSERT (! (-1 >  sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 179   ASSERT (  ( 0 >  sb));
 180   ASSERT (  ( 1 >  sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 181
 182   ASSERT (! (-2 >= sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 183   ASSERT (  (-1 >= sb));
 184   ASSERT (  ( 0 >= sb));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 185
 186
 187   ASSERT (! (-1 == ub));        /* WARNING(SDCC) */
 188   ASSERT (  ( 0 == ub));
 189   ASSERT (  ( 1 == ub));
 190   ASSERT (! ( 2 == ub));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 191
 192   ASSERT (  (-1 != ub));        /* WARNING(SDCC) */
 193   ASSERT (  ( 0 != ub));
 194   ASSERT (  ( 1 != ub));
 195   ASSERT (  ( 2 != ub));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 196
 197   ASSERT (  (-1 <  ub));        /* WARNING(SDCC) */
 198   ASSERT (  ( 0 <  ub));
 199   ASSERT (! ( 1 <  ub));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 200
 201   ASSERT (  ( 0 <= ub));        /* WARNING(SDCC) */
 202   ASSERT (  ( 1 <= ub));
 203   ASSERT (! ( 2 <= ub));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 204
 205   ASSERT (! ( 0 >  ub));        /* WARNING(SDCC) */
 206   ASSERT (  ( 1 >  ub));
 207   ASSERT (  ( 2 >  ub));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 208
 209   ASSERT (! (-1 >= ub));        /* WARNING(SDCC) */
 210   ASSERT (  ( 0 >= ub));
 211   ASSERT (  ( 1 >= ub));        /* WARNING(SDCC_mcs51|SDCC_ds390) */
 212 }
 213 #endif
 214
 215 #ifdef TEST4
 216 void foo(void)
 217 {
 218   volatile struct {
 219       signed sb1:1;
 220       signed sb3:3;
 221     unsigned ub1:1;
 222     unsigned ub3:3;
 223   } str;
 224
 225   str.sb1 = -2;                 /* WARNING */
 226   str.sb1 = -1;
 227   str.sb1 =  1;
 228   str.sb1 =  2;                 /* WARNING */
 229
 230   str.ub1 = -2;                 /* WARNING */
 231   str.ub1 = -1;
 232   str.ub1 =  1;
 233   str.ub1 =  2;                 /* WARNING */
 234
 235   str.sb3 = -5;                 /* WARNING */
 236   str.sb3 = -4;
 237   str.sb3 =  7;
 238   str.sb3 =  8;                 /* WARNING */
 239
 240   str.ub3 = -5;                 /* WARNING */
 241   str.ub3 = -4;
 242   str.ub3 =  7;
 243   str.ub3 =  8;                 /* WARNING */
 244
 245   ASSERT (! (-2 == str.sb1));   /* WARNING */
 246   ASSERT (  (-1 == str.sb1));
 247   ASSERT (  ( 0 == str.sb1));
 248   ASSERT (! ( 1 == str.sb1));   /* WARNING */
 249
 250   ASSERT (! (-1 == str.ub1));   /* WARNING(SDCC) */
 251   ASSERT (  ( 0 == str.ub1));
 252   ASSERT (  ( 1 == str.ub1));
 253   ASSERT (! ( 2 == str.ub1));   /* WARNING(SDCC) */
 254
 255   ASSERT (! (-5 == str.sb3));   /* WARNING */
 256   ASSERT (  (-4 == str.sb3));
 257   ASSERT (  ( 3 == str.sb3));
 258   ASSERT (! ( 4 == str.sb3));   /* WARNING */
 259
 260   ASSERT (! (-1 == str.ub3));   /* WARNING(SDCC) */
 261   ASSERT (  ( 0 == str.ub3));
 262   ASSERT (  ( 7 == str.ub3));
 263   ASSERT (! ( 8 == str.ub3));   /* WARNING(SDCC) */
 264 }
 265 #endif