sdcc/support/regression/tests/condopptr.c

   1 /* Test conditional operator with pointer operands
   2  */
   3 /* In addition to the usual promotion rules that apply to the operands */
   4 /* to all operators, the conditional operator has some special rules   */
   5 /* that apply to pointer types (as well as arrays, since an array      */
   6 /* reference is interchangeable with a pointer to the first element):   */
   7 /*   1. If the operands are a pointer and NULL, the resultant type     */
   8 /*      is that of the non-NULL pointer. NULL can be defined as either */
   9 /*      0 or (void *)0.                                                */
  10 /*   2. If the operands are a non-void pointer and a void (non-NULL)   */
  11 /*      pointer, the resultant type is that of the void pointer.       */
  12 #include <testfwk.h>
  13
  14 int testarray[5] = {3,2,7,6,8};
  15
  16 unsigned char cond;
  17
  18 void
  19 setcond(unsigned char state)
  20 {
  21   cond = state;
  22 }
  23
  24 int
  25 deref1(int *ip)
  26 {
  27   return *ip;
  28 }
  29
  30 int
  31 deref2(char *cp)
  32 {
  33   int *ip = (void *)cp;
  34   return *ip;
  35 }
  36
  37
  38 void
  39 testCondOpPtrTypes1(void)
  40 {
  41 #if !defined(__SDCC_pdk14) // Lack of memory
  42 #if !(defined (__SDCC_pdk15) && defined(__SDCC_STACK_AUTO)) // Lack of code memory
  43   int *ip1;
  44   int *ip2;
  45   void *vp1;
  46   void *vp2;
  47   char *cp;
  48
  49
  50   ip1 = &(testarray[2]);
  51
  52   setcond(1);
  53
  54   ip2 = cond ? testarray : ip1;    /* int[], int *  ==> int *  */
  55   ASSERT (*ip2 == 3);
  56   ip2 = cond ? ip1 : testarray;    /* int *, int[]  ==> int *  */
  57   ASSERT (*ip2 == 7);
  58
  59   ip2 = cond ? testarray : 0;      /* int[], 0      ==> int *  */
  60   ASSERT (*ip2 == 3);
  61   ip2 = cond ? ip1 : 0;            /* int *, 0      ==> int *  */
  62   ASSERT (*ip2 == 7);
  63
  64   ip2 = cond ? testarray : (void *)0;  /* int[], NULL   ==> int *  */
  65   ASSERT (*ip2 == 3);
  66   ip2 = cond ? ip1 : (void *)0;        /* int *, NULL   ==> int *  */
  67   ASSERT (*ip2 == 7);
  68
  69   vp1 = &(testarray[1]);
  70   ip2 = testarray;
  71   vp2 = cond ? testarray : vp1;        /* int[], void * ==> void * */
  72   ASSERT (vp2 == ip2);
  73   vp2 = cond ? ip1 : vp1;              /* int *, void * ==> void * */
  74   ASSERT (vp2 == ip1);
  75   cp = cond ? testarray : vp1;         /* int[], void * ==> void * */
  76   ASSERT ((int *)cp == ip2);
  77   cp = cond ? ip1 : vp1;               /* int *, void * ==> void * */
  78   ASSERT ((int *)cp == ip1);
  79
  80   ASSERT (deref1 (cond ? testarray : ip1) == 3);
  81   ASSERT (deref1 (cond ? ip1 : testarray) == 7);
  82   ASSERT (deref1 (cond ? testarray : 0) == 3);
  83   ASSERT (deref1 (cond ? ip1 : 0) == 7);
  84   ASSERT (deref1 (cond ? testarray : (void *)0) == 3);
  85   ASSERT (deref1 (cond ? ip1 : (void *)0) == 7);
  86
  87   /* These resolve to type void * and so are compatible with */
  88   /* the char * parameter */
  89   ASSERT (deref2 (cond ? testarray : vp1) == 3);
  90   ASSERT (deref2 (cond ? ip1 : vp1) == 7);
  91 #endif
  92 #endif
  93 }
  94
  95 void
  96 testCondOpPtrTypes2(void)
  97 {
  98 #if !defined(__SDCC_pdk14) // Lack of memory
  99 #if !(defined (__SDCC_pdk15) && defined(__SDCC_STACK_AUTO)) // Lack of code memory
 100   int *ip1;
 101   int *ip2;
 102   void *vp1;
 103   void *vp2;
 104   char *cp;
 105
 106   ip1 = &(testarray[2]);
 107
 108   setcond(0);
 109
 110   ip2 = cond ? testarray : ip1;    /* int[], int *  ==> int *  */
 111   ASSERT (*ip2 == 7);
 112   ip2 = cond ? ip1 : testarray;    /* int *, int[]  ==> int *  */
 113   ASSERT (*ip2 == 3);
 114
 115   ip2 = cond ? 0 : testarray;      /* 0, int[]      ==> int *  */
 116   ASSERT (*ip2 == 3);
 117   ip2 = cond ? 0: ip1;             /* 0, int *      ==> int *  */
 118   ASSERT (*ip2 == 7);
 119
 120   ip2 = cond ? (void *)0 : testarray;  /* NULL, int[]   ==> int *  */
 121   ASSERT (*ip2 == 3);
 122   ip2 = cond ? (void *)0 : ip1;        /* NULL, int *   ==> int *  */
 123   ASSERT (*ip2 == 7);
 124
 125   vp1 = &(testarray[1]);
 126   ip2 = testarray;
 127   vp2 = cond ? vp1 : testarray;        /* void *, int[] ==> void * */
 128   ASSERT (vp2 == ip2);
 129   vp2 = cond ? vp1 : ip1;              /* void *, int * ==> void * */
 130   ASSERT (vp2 == ip1);
 131   cp = cond ? vp1 : testarray;         /* void *, int[] ==> void * */
 132   ASSERT ((int *)cp == ip2);
 133   cp = cond ? vp1 : ip1;               /* void *, int * ==> void * */
 134   ASSERT ((int *)cp == ip1);
 135
 136   ASSERT (deref1 (cond ? testarray : ip1) == 7);
 137   ASSERT (deref1 (cond ? ip1 : testarray) == 3);
 138   ASSERT (deref1 (cond ? 0 : testarray) == 3);
 139   ASSERT (deref1 (cond ? 0 : ip1) == 7);
 140   ASSERT (deref1 (cond ? (void *)0 : testarray) == 3);
 141   ASSERT (deref1 (cond ? (void *)0 : ip1) == 7);
 142
 143   /* These resolve to type void * and so are compatible with */
 144   /* the char * parameter */
 145   ASSERT (deref2 (cond ? vp1 : testarray) == 3);
 146   ASSERT (deref2 (cond ? vp1 : ip1) == 7);
 147 #endif
 148 #endif
 149 }
 150
 151 int
 152 foo0(int a, int b, int c)
 153 {
 154   return a > 10 ? ++b, ++c : b + c;
 155 }
 156
 157 int
 158 foo1(int a, int b, int c, int d)
 159 {
 160   return a > 20 ? ++b, ++c, ++d + b + c : b < 100 ? c + ++d : c - --d;
 161 }
 162
 163 void
 164 testBug2412(void)
 165 {
 166   ASSERT (foo0 (2, 4, 5) == 9);
 167   ASSERT (foo0 (72, 84, 5) == 6);
 168   ASSERT (foo0 (7, 84, 75) == 159);
 169
 170   ASSERT (foo1 (110, 12, 13, 15) == 43);
 171   ASSERT (foo1 (18, 12, 13, 15) == 29);
 172   ASSERT (foo1 (12, 129, 13, 13) == 1);
 173 }