git.m6w6.name Git - m6w6/ext-psi/blob - src/calc.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "config.h"
   3 #endif
   4
   5 #include "php.h"
   6 #include "php_psi.h"
   7
   8 static inline int psi_calc_num_exp_value(num_exp *exp, impl_val *strct, impl_val *res) {
   9         impl_val *ref, *tmp = NULL;
  10
  11         switch (exp->t) {
  12         case PSI_T_NUMBER:
  13                 switch (is_numeric_string(exp->u.numb, strlen(exp->u.numb), (zend_long *) res, (double *) res, 0)) {
  14                 case IS_LONG:
  15                         return PSI_T_INT64;
  16                 case IS_DOUBLE:
  17                         return PSI_T_DOUBLE;
  18                 }
  19                 break;
  20
  21         case PSI_T_NSNAME:
  22                 switch (exp->u.cnst->type->type) {
  23                 case PSI_T_INT:
  24                         res->i64 = zend_get_constant_str(exp->u.cnst->name, strlen(exp->u.cnst->name))->value.lval;
  25                         return PSI_T_INT64;
  26                 case PSI_T_FLOAT:
  27                         res->dval = zend_get_constant_str(exp->u.cnst->name, strlen(exp->u.cnst->name))->value.dval;
  28                         return PSI_T_DOUBLE;
  29                 default:
  30                         return 0;
  31                 }
  32                 break;
  33
  34         case PSI_T_NAME:
  35                 if (strct) {
  36                         ref = struct_member_ref(exp->u.dvar->arg, strct, &tmp);
  37                 } else if (exp->u.dvar->arg->let) {
  38                         ref = exp->u.dvar->arg->let->ptr;
  39                 } else {
  40                         ref = exp->u.dvar->arg->ptr;
  41                 }
  42                 switch (real_decl_type(exp->u.dvar->arg->type)->type) {
  43                 case PSI_T_INT8:
  44                 case PSI_T_UINT8:
  45                 case PSI_T_INT16:
  46                 case PSI_T_UINT16:
  47                 case PSI_T_INT32:
  48                 case PSI_T_UINT32:
  49                 case PSI_T_INT64:
  50                 case PSI_T_UINT64:
  51                         memcpy(res, deref_impl_val(ref, exp->u.dvar), sizeof(*res));
  52                         if (tmp) {
  53                                 free(tmp);
  54                         }
  55                         return real_decl_type(exp->u.dvar->arg->type)->type;
  56
  57                 case PSI_T_FLOAT:
  58                 case PSI_T_DOUBLE:
  59                         memcpy(res, deref_impl_val(ref, exp->u.dvar), sizeof(*res));
  60                         if (tmp) {
  61                                 free(tmp);
  62                         }
  63                         return real_decl_type(exp->u.dvar->arg->type)->type;
  64
  65                 EMPTY_SWITCH_DEFAULT_CASE();
  66                 }
  67                 break;
  68
  69         EMPTY_SWITCH_DEFAULT_CASE();
  70         }
  71         return  0;
  72 }
  73
  74 int psi_calc_num_exp(num_exp *exp, impl_val *strct, impl_val *res) {
  75         impl_val num = {0};
  76         int num_type = psi_calc_num_exp_value(exp, strct, &num);
  77
  78         if (exp->operand) {
  79                 impl_val tmp = {0};
  80                 int tmp_type = psi_calc_num_exp(exp->operand, strct, &tmp);
  81
  82                 return exp->calculator(num_type, &num, tmp_type, &tmp, res);
  83         }
  84
  85         memcpy(res, &num, sizeof(*res));
  86         return num_type;
  87 }
  88
  89 #define PRIfval "f"
  90 #define PRIdval "lf"
  91 #define PRIldval "Lf"
  92
  93 #define PSI_CALC_OP(var) do { \
  94         const char *fmt = "calc %" PRI##var ", %" PRI##var ": %" PRI##var "\n"; \
  95         res->var = PSI_CALC(v1->var, v2->var); \
  96         if (!res->var) fprintf(stderr, fmt, v1->var, v2->var, res->var); \
  97 } while (0)
  98 #define PSI_CALC_OP2(vres, var1, var2) do { \
  99         const char *fmt = "calc %" PRI##var1 ", %" PRI##var2 ": %" PRI##vres "\n"; \
 100         res->vres = PSI_CALC(v1->var1, v2->var2); \
 101         if (!res->vres) fprintf(stderr, fmt, v1->var1, v2->var2, res->vres); \
 102 } while(0)
 103
 104 #ifdef HAVE_LONG_DOUBLE
 105 #define PSI_CALC_NO_LD
 106 #define PSI_CALC_OP_LD PSI_CALC_OP(ldval)
 107 #define PSI_CALC_OP2_LD2(var1) PSI_CALC_OP2(ldval, var1, ldval)
 108 #define PSI_CALC_OP2_LD1(var2) PSI_CALC_OP2(ldval, ldval, var2)
 109 #else
 110 #define PSI_CALC_NO_LD abort()
 111 #define PSI_CALC_OP_LD PSI_CALC_NO_LD
 112 #define PSI_CALC_OP2_LD2(var) PSI_CALC_NO_LD
 113 #define PSI_CALC_OP2_LD1(var) PSI_CALC_NO_LD
 114 #endif
 115
 116 #define PSI_CALC_FN(op) int psi_calc_##op(int t1, impl_val *v1, int t2, impl_val *v2, impl_val *res) \
 117 { \
 118         if (t1 == t2) { \
 119                 switch (t1) { \
 120                 case PSI_T_FLOAT:       PSI_CALC_OP(fval);      break; \
 121                 case PSI_T_DOUBLE:      PSI_CALC_OP(dval);      break; \
 122                 case PSI_T_LONG_DOUBLE: PSI_CALC_OP_LD; break; \
 123                 case PSI_T_INT8:        PSI_CALC_OP(i8);        break; \
 124                 case PSI_T_UINT8:       PSI_CALC_OP(u8);        break; \
 125                 case PSI_T_INT16:       PSI_CALC_OP(i16);       break; \
 126                 case PSI_T_UINT16:      PSI_CALC_OP(u16);       break; \
 127                 case PSI_T_INT32:       PSI_CALC_OP(i32);       break; \
 128                 case PSI_T_UINT32:      PSI_CALC_OP(u32);       break; \
 129                 case PSI_T_INT64:       PSI_CALC_OP(i64);       break; \
 130                 case PSI_T_UINT64:      PSI_CALC_OP(u64);       break; \
 131                 EMPTY_SWITCH_DEFAULT_CASE(); \
 132                 } \
 133                 return t1; \
 134         } else if (t1 == PSI_T_DOUBLE) { \
 135                 switch (t2) { \
 136                 case PSI_T_LONG_DOUBLE: PSI_CALC_OP2_LD2(dval);         return t2; \
 137                 case PSI_T_FLOAT:       PSI_CALC_OP2(dval, dval, fval); break; \
 138                 case PSI_T_INT8:        PSI_CALC_OP2(dval, dval, i8);   break; \
 139                 case PSI_T_UINT8:       PSI_CALC_OP2(dval, dval, u8);   break; \
 140                 case PSI_T_INT16:       PSI_CALC_OP2(dval, dval, i16);  break; \
 141                 case PSI_T_UINT16:      PSI_CALC_OP2(dval, dval, u16);  break; \
 142                 case PSI_T_INT32:       PSI_CALC_OP2(dval, dval, i32);  break; \
 143                 case PSI_T_UINT32:      PSI_CALC_OP2(dval, dval, u32);  break; \
 144                 case PSI_T_INT64:       PSI_CALC_OP2(dval, dval, i64);  break; \
 145                 case PSI_T_UINT64:      PSI_CALC_OP2(dval, dval, u64);  break; \
 146                 EMPTY_SWITCH_DEFAULT_CASE(); \
 147                 } \
 148                 return t1; \
 149         } else if (t2 == PSI_T_DOUBLE) { \
 150                 switch (t1) { \
 151                 case PSI_T_LONG_DOUBLE: PSI_CALC_OP2_LD1(dval);         return t1; \
 152                 case PSI_T_FLOAT:       PSI_CALC_OP2(dval, fval, dval); break; \
 153                 case PSI_T_INT8:        PSI_CALC_OP2(dval, i8, dval);   break; \
 154                 case PSI_T_UINT8:       PSI_CALC_OP2(dval, u8, dval);   break; \
 155                 case PSI_T_INT16:       PSI_CALC_OP2(dval, i16, dval);  break; \
 156                 case PSI_T_UINT16:      PSI_CALC_OP2(dval, u16, dval);  break; \
 157                 case PSI_T_INT32:       PSI_CALC_OP2(dval, i32, dval);  break; \
 158                 case PSI_T_UINT32:      PSI_CALC_OP2(dval, u32, dval);  break; \
 159                 case PSI_T_INT64:       PSI_CALC_OP2(dval, i64, dval);  break; \
 160                 case PSI_T_UINT64:      PSI_CALC_OP2(dval, u64, dval);  break; \
 161                 EMPTY_SWITCH_DEFAULT_CASE(); \
 162                 } \
 163                 return t2; \
 164         } else if (t1 == PSI_T_LONG_DOUBLE) { \
 165                 PSI_CALC_NO_LD; \
 166                 switch (t2) { \
 167                 case PSI_T_DOUBLE:      PSI_CALC_OP2_LD1(dval); break; \
 168                 case PSI_T_FLOAT:       PSI_CALC_OP2_LD1(fval); break; \
 169                 case PSI_T_INT8:        PSI_CALC_OP2_LD1(i8);   break; \
 170                 case PSI_T_UINT8:       PSI_CALC_OP2_LD1(u8);   break; \
 171                 case PSI_T_INT16:       PSI_CALC_OP2_LD1(i16);  break; \
 172                 case PSI_T_UINT16:      PSI_CALC_OP2_LD1(u16);  break; \
 173                 case PSI_T_INT32:       PSI_CALC_OP2_LD1(i32);  break; \
 174                 case PSI_T_UINT32:      PSI_CALC_OP2_LD1(u32);  break; \
 175                 case PSI_T_INT64:       PSI_CALC_OP2_LD1(i64);  break; \
 176                 case PSI_T_UINT64:      PSI_CALC_OP2_LD1(u64);  break; \
 177                 EMPTY_SWITCH_DEFAULT_CASE(); \
 178                 } \
 179                 return t1; \
 180         } else if (t2 == PSI_T_LONG_DOUBLE) { \
 181                 PSI_CALC_NO_LD; \
 182                 switch (t1) { \
 183                 case PSI_T_DOUBLE:      PSI_CALC_OP2_LD2(dval); break; \
 184                 case PSI_T_FLOAT:       PSI_CALC_OP2_LD2(fval); break; \
 185                 case PSI_T_INT8:        PSI_CALC_OP2_LD2(i8);   break; \
 186                 case PSI_T_UINT8:       PSI_CALC_OP2_LD2(u8);   break; \
 187                 case PSI_T_INT16:       PSI_CALC_OP2_LD2(i16);  break; \
 188                 case PSI_T_UINT16:      PSI_CALC_OP2_LD2(u16);  break; \
 189                 case PSI_T_INT32:       PSI_CALC_OP2_LD2(i32);  break; \
 190                 case PSI_T_UINT32:      PSI_CALC_OP2_LD2(u32);  break; \
 191                 case PSI_T_INT64:       PSI_CALC_OP2_LD2(i64);  break; \
 192                 case PSI_T_UINT64:      PSI_CALC_OP2_LD2(u64);  break; \
 193                 EMPTY_SWITCH_DEFAULT_CASE(); \
 194                 } \
 195                 return t2; \
 196         } else if (t1 == PSI_T_FLOAT) { \
 197                 switch (t2) { \
 198                 case PSI_T_LONG_DOUBLE: PSI_CALC_OP2_LD2(fval);         return t2; \
 199                 case PSI_T_DOUBLE:      PSI_CALC_OP2(dval, fval, dval); return t2; \
 200                 case PSI_T_INT8:        PSI_CALC_OP2(fval, fval, i8);   break; \
 201                 case PSI_T_UINT8:       PSI_CALC_OP2(fval, fval, u8);   break; \
 202                 case PSI_T_INT16:       PSI_CALC_OP2(fval, fval, i16);  break; \
 203                 case PSI_T_UINT16:      PSI_CALC_OP2(fval, fval, u16);  break; \
 204                 case PSI_T_INT32:       PSI_CALC_OP2(fval, fval, i32);  break; \
 205                 case PSI_T_UINT32:      PSI_CALC_OP2(fval, fval, u32);  break; \
 206                 case PSI_T_INT64:       PSI_CALC_OP2(fval, fval, i64);  break; \
 207                 case PSI_T_UINT64:      PSI_CALC_OP2(fval, fval, u64);  break; \
 208                 EMPTY_SWITCH_DEFAULT_CASE(); \
 209                 } \
 210                 return t1; \
 211         } else if (t2 == PSI_T_FLOAT) { \
 212                 switch (t1) { \
 213                 case PSI_T_LONG_DOUBLE: PSI_CALC_OP2_LD1(fval);         return t1; \
 214                 case PSI_T_DOUBLE:      PSI_CALC_OP2(dval, dval, fval); return t1; \
 215                 case PSI_T_INT8:        PSI_CALC_OP2(fval, i8, fval);   break; \
 216                 case PSI_T_UINT8:       PSI_CALC_OP2(fval, u8, fval);   break; \
 217                 case PSI_T_INT16:       PSI_CALC_OP2(fval, i16, fval);  break; \
 218                 case PSI_T_UINT16:      PSI_CALC_OP2(fval, u16, fval);  break; \
 219                 case PSI_T_INT32:       PSI_CALC_OP2(fval, i32, fval);  break; \
 220                 case PSI_T_UINT32:      PSI_CALC_OP2(fval, u32, fval);  break; \
 221                 case PSI_T_INT64:       PSI_CALC_OP2(fval, i64, fval);  break; \
 222                 case PSI_T_UINT64:      PSI_CALC_OP2(fval, u64, fval);  break; \
 223                 EMPTY_SWITCH_DEFAULT_CASE(); \
 224                 } \
 225                 return t2; \
 226         } else { \
 227                 int64_t sval1 = v1->i64, sval2 = v2->i64; \
 228                 uint64_t uval1 = v1->u64, uval2 = v2->u64; \
 229                 switch (t1) { \
 230                 case PSI_T_INT8:        sval1 >>= 8; \
 231                 case PSI_T_INT16:       sval1 >>= 8; \
 232                 case PSI_T_INT32:       sval1 >>= 8; \
 233                 case PSI_T_INT64: \
 234                         switch (t2) { \
 235                         case PSI_T_INT8:        sval2 >>= 8; \
 236                         case PSI_T_INT16:       sval2 >>= 8; \
 237                         case PSI_T_INT32:       sval2 >>= 8; \
 238                         case PSI_T_INT64: \
 239                                 res->i64 = PSI_CALC(sval1 , sval2); \
 240                                 return PSI_T_INT64; \
 241                         case PSI_T_UINT8:       uval2 >>= 8; \
 242                         case PSI_T_UINT16:      uval2 >>= 8; \
 243                         case PSI_T_UINT32:      uval2 >>= 8; \
 244                         case PSI_T_UINT64: \
 245                                 res->i64 = PSI_CALC(sval1, uval2); \
 246                                 return PSI_T_INT64; \
 247                         } \
 248                         break; \
 249                 case PSI_T_UINT8:       uval1 >>= 8; \
 250                 case PSI_T_UINT16:      uval1 >>= 8; \
 251                 case PSI_T_UINT32:      uval1 >>= 8; \
 252                 case PSI_T_UINT64: \
 253                         switch (t2) { \
 254                         case PSI_T_INT8:        sval2 >>= 8; \
 255                         case PSI_T_INT16:       sval2 >>= 8; \
 256                         case PSI_T_INT32:       sval2 >>= 8; \
 257                         case PSI_T_INT64: \
 258                                 res->i64 = PSI_CALC(uval1, sval2); \
 259                                 return PSI_T_INT64; \
 260                         case PSI_T_UINT8:       uval2 >>= 8; \
 261                         case PSI_T_UINT16:      uval2 >>= 8; \
 262                         case PSI_T_UINT32:      uval2 >>= 8; \
 263                         case PSI_T_UINT64: \
 264                                 res->u64 = PSI_CALC(uval1, uval2); \
 265                                 return PSI_T_UINT64; \
 266                         } \
 267                         break; \
 268                 } \
 269         } \
 270         ZEND_ASSERT(0); \
 271         return 0; \
 272 }
 273
 274 #undef PSI_CALC
 275 #define PSI_CALC(var1, var2) (var1) + (var2)
 276 PSI_CALC_FN(add)
 277 #undef PSI_CALC
 278 #define PSI_CALC(var1, var2) (var1) * (var2)
 279 PSI_CALC_FN(mul)
 280 #undef PSI_CALC
 281 #define PSI_CALC(var1, var2) (var1) - (var2)
 282 PSI_CALC_FN(sub)
 283 #undef PSI_CALC
 284 #define PSI_CALC(var1, var2) (var1) / (var2)
 285 PSI_CALC_FN(div)