10 static inline int psi_calc_num_exp_value(num_exp
*exp
, impl_val
*strct
, impl_val
*res
) {
11 impl_val
*ref
, *tmp
= NULL
;
15 switch (is_numeric_string(exp
->u
.numb
, strlen(exp
->u
.numb
), (zend_long
*) res
, (double *) res
, 0)) {
24 switch (exp
->u
.cnst
->type
->type
) {
26 res
->i64
= zend_get_constant_str(exp
->u
.cnst
->name
, strlen(exp
->u
.cnst
->name
))->value
.lval
;
29 res
->dval
= zend_get_constant_str(exp
->u
.cnst
->name
, strlen(exp
->u
.cnst
->name
))->value
.dval
;
37 return psi_calc_num_exp(exp
->u
.enm
->num
?: &exp
->u
.enm
->inc
, NULL
, res
);
42 ref
= struct_member_ref(exp
->u
.dvar
->arg
, strct
, &tmp
);
44 ref
= exp
->u
.dvar
->arg
->let
;
46 switch (real_decl_type(exp
->u
.dvar
->arg
->type
)->type
) {
55 memcpy(res
, deref_impl_val(ref
, exp
->u
.dvar
), sizeof(*res
));
59 return real_decl_type(exp
->u
.dvar
->arg
->type
)->type
;
63 memcpy(res
, deref_impl_val(ref
, exp
->u
.dvar
), sizeof(*res
));
67 return real_decl_type(exp
->u
.dvar
->arg
->type
)->type
;
69 EMPTY_SWITCH_DEFAULT_CASE();
73 EMPTY_SWITCH_DEFAULT_CASE();
78 int psi_calc_num_exp(num_exp
*exp
, impl_val
*strct
, impl_val
*res
) {
80 int num_type
= psi_calc_num_exp_value(exp
, strct
, &num
);
84 int tmp_type
= psi_calc_num_exp(exp
->operand
, strct
, &tmp
);
86 return exp
->calculator(num_type
, &num
, tmp_type
, &tmp
, res
);
89 memcpy(res
, &num
, sizeof(*res
));
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); \
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); \
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)
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
120 #define PSI_CALC_FN(op) int psi_calc_##op(int t1, impl_val *v1, int t2, impl_val *v2, impl_val *res) \
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(); \
138 } else if (t1 == PSI_T_DOUBLE) { \
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(); \
153 } else if (t2 == PSI_T_DOUBLE) { \
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(); \
168 } else if (t1 == PSI_T_LONG_DOUBLE) { \
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(); \
184 } else if (t2 == PSI_T_LONG_DOUBLE) { \
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(); \
200 } else if (t1 == PSI_T_FLOAT) { \
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(); \
215 } else if (t2 == PSI_T_FLOAT) { \
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(); \
231 int64_t sval1 = v1->i64, sval2 = v2->i64; \
232 uint64_t uval1 = v1->u64, uval2 = v2->u64; \
234 case PSI_T_INT8: sval1 >>= 8; \
235 case PSI_T_INT16: sval1 >>= 8; \
236 case PSI_T_INT32: sval1 >>= 8; \
239 case PSI_T_INT8: sval2 >>= 8; \
240 case PSI_T_INT16: sval2 >>= 8; \
241 case PSI_T_INT32: sval2 >>= 8; \
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; \
249 res->i64 = PSI_CALC(sval1, uval2); \
250 return PSI_T_INT64; \
253 case PSI_T_UINT8: uval1 >>= 8; \
254 case PSI_T_UINT16: uval1 >>= 8; \
255 case PSI_T_UINT32: uval1 >>= 8; \
258 case PSI_T_INT8: sval2 >>= 8; \
259 case PSI_T_INT16: sval2 >>= 8; \
260 case PSI_T_INT32: sval2 >>= 8; \
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; \
268 res->u64 = PSI_CALC(uval1, uval2); \
269 return PSI_T_UINT64; \
279 #define PSI_CALC(var1, var2) (var1) + (var2)
282 #define PSI_CALC(var1, var2) (var1) * (var2)
285 #define PSI_CALC(var1, var2) (var1) - (var2)
288 #define PSI_CALC(var1, var2) (var1) / (var2)