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