projects / m6w6 / ext-psi / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
Merge branch 'more-validations'
[m6w6/ext-psi] / src / marshal.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 "marshal.h"
9 #include "calc.h"
10
11 void psi_to_void(zval *return_value, set_value *set, impl_val *ret_val)
12 {
13 RETVAL_NULL();
14 }
15
16 void psi_to_zval(zval *return_value, set_value *set, impl_val *ret_val) {
17 RETVAL_ZVAL(ret_val->ptr, 1, 0);
18 }
19
20 impl_val *psi_let_zval(impl_val *tmp, decl_type *type, impl_arg *iarg, void **to_free)
21 {
22 *to_free = tmp->ptr = emalloc(sizeof(zval));
23 ZVAL_COPY_VALUE(tmp->ptr, iarg->_zv);
24 return tmp;
25 }
26
27 void psi_to_bool(zval *return_value, set_value *set, impl_val *ret_val)
28 {
29 psi_to_int(return_value, set, ret_val);
30 convert_to_boolean(return_value);
31 }
32
33 static inline impl_val *psi_val_boolval(impl_val *tmp, token_t real_type, zend_bool boolval) {
34 switch (real_type) {
35 case PSI_T_INT8: tmp->i8 = boolval; break;
36 case PSI_T_UINT8: tmp->u8 = boolval; break;
37 case PSI_T_INT16: tmp->i16 = boolval; break;
38 case PSI_T_UINT16: tmp->u16 = boolval; break;
39 case PSI_T_INT32: tmp->i32 = boolval; break;
40 case PSI_T_UINT32: tmp->u32 = boolval; break;
41 case PSI_T_INT64: tmp->i64 = boolval; break;
42 case PSI_T_UINT64: tmp->u64 = boolval; break;
43 case PSI_T_FLOAT: tmp->fval = boolval; break;
44 case PSI_T_DOUBLE: tmp->dval = boolval; break;
45 #ifdef HAVE_LONG_DOUBLE
46 case PSI_T_LONG_DOUBLE: tmp->ldval = boolval; break;
47 #endif
48 EMPTY_SWITCH_DEFAULT_CASE();
49 }
50 return tmp;
51 }
52
53 impl_val *psi_let_boolval(impl_val *tmp, decl_type *type, impl_arg *iarg, void **to_free)
54 {
55 zend_bool boolval;
56 token_t real_type = type ? real_decl_type(type)->type : PSI_T_UINT8;
57
58 if (iarg->type->type == PSI_T_BOOL) {
59 boolval = iarg->val.zend.bval;
60 } else {
61 boolval = zend_is_true(iarg->_zv);
62 }
63
64 return psi_val_boolval(tmp, real_type, boolval);
65 }
66
67 # define RETVAL_LONG_U64(V) \
68 if (V > ZEND_LONG_MAX) { \
69 char d[24] = {0}; \
70 RETVAL_STRING(zend_print_ulong_to_buf(&d[22], V)); \
71 } else { \
72 RETVAL_LONG(V); \
73 }
74
75 void psi_to_int(zval *return_value, set_value *set, impl_val *ret_val)
76 {
77 decl_var *var = set->vars->vars[0];
78 token_t t = real_decl_type(var->arg->type)->type;
79 impl_val *v = deref_impl_val(ret_val, var);
80
81 switch (t) {
82 case PSI_T_INT8: RETVAL_LONG(v->i8); break;
83 case PSI_T_UINT8: RETVAL_LONG(v->u8); break;
84 case PSI_T_INT16: RETVAL_LONG(v->i16); break;
85 case PSI_T_UINT16: RETVAL_LONG(v->u16); break;
86 case PSI_T_INT32: RETVAL_LONG(v->i32); break;
87 case PSI_T_UINT32: RETVAL_LONG(v->u32); break;
88 case PSI_T_INT64: RETVAL_LONG(v->i64); break;
89 case PSI_T_UINT64: RETVAL_LONG_U64(v->u64); break;
90 case PSI_T_FLOAT: RETVAL_DOUBLE((double) v->fval); break;
91 case PSI_T_DOUBLE: RETVAL_DOUBLE(v->dval); break;
92 #ifdef HAVE_LONG_DOUBLE
93 case PSI_T_LONG_DOUBLE: RETVAL_DOUBLE((double) v->ldval); break;
94 #endif
95 EMPTY_SWITCH_DEFAULT_CASE();
96 }
97
98 convert_to_long(return_value);
99 }
100
101 static inline impl_val *psi_val_intval(impl_val *tmp, token_t real_type, zend_long intval) {
102 switch (real_type) {
103 case PSI_T_INT8: tmp->i8 = intval; break;
104 case PSI_T_UINT8: tmp->u8 = intval; break;
105 case PSI_T_INT16: tmp->i16 = intval; break;
106 case PSI_T_UINT16: tmp->u16 = intval; break;
107 case PSI_T_INT32: tmp->i32 = intval; break;
108 case PSI_T_UINT32: tmp->u32 = intval; break;
109 case PSI_T_INT64: tmp->i64 = intval; break;
110 case PSI_T_UINT64: tmp->u64 = intval; break;
111 case PSI_T_INT: tmp->ival = intval; break;
112 case PSI_T_LONG: tmp->lval = intval; break;
113 case PSI_T_FLOAT: tmp->fval = intval; break;
114 case PSI_T_DOUBLE: tmp->dval = intval; break;
115 #ifdef HAVE_LONG_DOUBLE
116 case PSI_T_LONG_DOUBLE: tmp->ldval = intval; break;
117 #endif
118 EMPTY_SWITCH_DEFAULT_CASE();
119 }
120
121 return tmp;
122 }
123
124 impl_val *psi_let_intval(impl_val *tmp, decl_type *type, impl_arg *iarg, void **to_free)
125 {
126 zend_long intval;
127 token_t real_type = type ? real_decl_type(type)->type : PSI_T_LONG;
128
129 if (iarg->type->type == PSI_T_INT) {
130 intval = iarg->val.zend.lval;
131 } else {
132 intval = zval_get_long(iarg->_zv);
133 }
134
135 return psi_val_intval(tmp, real_type, intval);
136 }
137
138 void psi_to_double(zval *return_value, set_value *set, impl_val *ret_val)
139 {
140 decl_var *var = set->vars->vars[0];
141 token_t t = real_decl_type(var->arg->type)->type;
142 impl_val *v = deref_impl_val(ret_val, var);
143
144 switch (t) {
145 case PSI_T_FLOAT: RETVAL_DOUBLE((double) v->fval); break;
146 case PSI_T_DOUBLE: RETVAL_DOUBLE(v->dval); break;
147 #ifdef HAVE_LONG_DOUBLE
148 case PSI_T_LONG_DOUBLE: RETVAL_DOUBLE((double) v->ldval); break;
149 #endif
150 case PSI_T_INT8: RETVAL_DOUBLE((double) v->i8); break;
151 case PSI_T_UINT8: RETVAL_DOUBLE((double) v->u8); break;
152 case PSI_T_INT16: RETVAL_DOUBLE((double) v->i16); break;
153 case PSI_T_UINT16: RETVAL_DOUBLE((double) v->u16); break;
154 case PSI_T_INT32: RETVAL_DOUBLE((double) v->i32); break;
155 case PSI_T_UINT32: RETVAL_DOUBLE((double) v->u32); break;
156 case PSI_T_INT64: RETVAL_DOUBLE((double) v->i64); break;
157 case PSI_T_UINT64: RETVAL_DOUBLE((double) v->u64); break;
158 EMPTY_SWITCH_DEFAULT_CASE();
159 }
160 }
161
162 static inline impl_val *psi_val_floatval(impl_val *tmp, token_t real_type, double floatval) {
163 switch (real_type) {
164 case PSI_T_INT8: tmp->i8 = floatval; break;
165 case PSI_T_UINT8: tmp->u8 = floatval; break;
166 case PSI_T_INT16: tmp->i16 = floatval; break;
167 case PSI_T_UINT16: tmp->u16 = floatval; break;
168 case PSI_T_INT32: tmp->i32 = floatval; break;
169 case PSI_T_UINT32: tmp->u32 = floatval; break;
170 case PSI_T_INT64: tmp->i64 = floatval; break;
171 case PSI_T_UINT64: tmp->u64 = floatval; break;
172 case PSI_T_FLOAT: tmp->fval = floatval; break;
173 case PSI_T_DOUBLE: tmp->dval = floatval; break;
174 #ifdef HAVE_LONG_DOUBLE
175 case PSI_T_LONG_DOUBLE: tmp->ldval = floatval; break;
176 #endif
177 EMPTY_SWITCH_DEFAULT_CASE();
178 }
179
180 return tmp;
181 }
182
183 impl_val *psi_let_floatval(impl_val *tmp, decl_type *type, impl_arg *iarg, void **to_free)
184 {
185 double floatval;
186 token_t real_type = type ? real_decl_type(type)->type : PSI_T_DOUBLE;
187
188 if (iarg->type->type == PSI_T_FLOAT || iarg->type->type == PSI_T_DOUBLE) {
189 floatval = iarg->val.dval;
190 } else {
191 floatval = zval_get_double(iarg->_zv);
192 }
193
194 return psi_val_floatval(tmp, real_type, floatval);
195 }
196
197 void psi_to_string(zval *return_value, set_value *set, impl_val *ret_val)
198 {
199 char *str;
200 decl_var *var = set->vars->vars[0];
201 token_t t = real_decl_type(var->arg->type)->type;
202
203 switch (t) {
204 case PSI_T_FLOAT: RETVAL_DOUBLE((double) deref_impl_val(ret_val, var)->fval); break;
205 case PSI_T_DOUBLE: RETVAL_DOUBLE(deref_impl_val(ret_val, var)->dval); break;
206 #ifdef HAVE_LONG_DOUBLE
207 case PSI_T_LONG_DOUBLE: RETVAL_DOUBLE((double) deref_impl_val(ret_val, var)->ldval); break;
208 #endif
209 default:
210 if (!var->arg->var->pointer_level) {
211 RETVAL_STRINGL(&ret_val->cval, 1);
212 } else {
213 ret_val = deref_impl_val(ret_val, var);
214 if (var->arg->var->array_size) {
215 str = (char *) ret_val;
216 } else {
217 str = ret_val->ptr;
218 }
219 if (str) {
220 if (set->num) {
221 zend_long n = psi_long_num_exp(set->num, set->outer.val);
222 RETVAL_STRINGL(str, n);
223 } else {
224 RETVAL_STRING(str);
225 }
226 } else {
227 RETVAL_EMPTY_STRING();
228 }
229 }
230 return;
231 }
232
233 convert_to_string(return_value);
234 }
235
236 impl_val *psi_let_strval(impl_val *tmp, decl_type *type, impl_arg *iarg, void **to_free)
237 {
238 if (iarg->type->type == PSI_T_STRING) {
239 if (iarg->val.zend.str) {
240 tmp->ptr = estrndup(iarg->val.zend.str->val, iarg->val.zend.str->len);
241 *to_free = tmp->ptr;
242 } else {
243 tmp->ptr = "";
244 }
245 } else {
246 zend_string *zs = zval_get_string(iarg->_zv);
247 tmp->ptr = estrdup(zs->val);
248 *to_free = tmp->ptr;
249 zend_string_release(zs);
250 }
251
252 return tmp;
253 }
254
255 impl_val *psi_let_pathval(impl_val *tmp, decl_type *type, impl_arg *iarg, void **to_free)
256 {
257 tmp = psi_let_strval(tmp, type, iarg, to_free);
258 if (SUCCESS != php_check_open_basedir(tmp->ptr)) {
259 efree(tmp->ptr);
260 return *to_free = NULL;
261 }
262 return tmp;
263 }
264
265 impl_val *psi_let_strlen(impl_val *tmp, decl_type *type, impl_arg *iarg, void **to_free)
266 {
267 if (iarg->type->type == PSI_T_STRING) {
268 if (iarg->val.zend.str) {
269 tmp->lval = iarg->val.zend.str->len;
270 } else {
271 tmp->lval = 0;
272 }
273 } else {
274 zend_string *zs = zval_get_string(iarg->_zv);
275 tmp->lval = zs->len;
276 zend_string_release(zs);
277 }
278
279 return tmp;
280 }
281
282 static impl_val *iterate(impl_val *val, size_t size, unsigned i, impl_val *tmp)
283 {
284 memset(tmp, 0, sizeof(*tmp));
285 memcpy(tmp, ((void*) val) + size * i, size);
286 return tmp;
287 }
288
289 void psi_from_zval_ex(impl_val **ptr, decl_arg *spec, token_t cast, zval *zv, void **tmp)
290 {
291 decl_type *real = real_decl_type(spec->type);
292 impl_val *val = *ptr;
293
294 switch (real->type) {
295 default:
296 ZEND_ASSERT(0);
297 /* no break */
298 case PSI_T_INT8:
299 val->i8 = zval_get_long(zv);
300 break;
301 case PSI_T_UINT8:
302 val->u8 = zval_get_long(zv);
303 break;
304 case PSI_T_INT16:
305 val->i16 = zval_get_long(zv);
306 break;
307 case PSI_T_UINT16:
308 val->u16 = zval_get_long(zv);
309 break;
310 case PSI_T_INT32:
311 val->i32 = zval_get_long(zv);
312 break;
313 case PSI_T_UINT32:
314 val->u32 = zval_get_long(zv);
315 break;
316 case PSI_T_INT64:
317 val->i64 = zval_get_long(zv);
318 break;
319 case PSI_T_UINT64:
320 val->u64 = zval_get_long(zv);
321 break;
322 case PSI_T_FLOAT:
323 val->fval = zval_get_double(zv);
324 break;
325 case PSI_T_DOUBLE:
326 val->dval = zval_get_double(zv);
327 break;
328 #ifdef HAVE_LONG_DOUBLE
329 case PSI_T_LONG_DOUBLE:
330 val->ldval = zval_get_double(zv);
331 break;
332 #endif
333 case PSI_T_ENUM:
334 val->ival = zval_get_long(zv);
335 break;
336 case PSI_T_STRUCT:
337 *tmp = *ptr = psi_array_to_struct(real->real.strct, HASH_OF(zv));
338 break;
339 }
340 }
341
342 void psi_from_zval(impl_val *mem, decl_arg *spec, zval *zv, void **tmp)
343 {
344 decl_type *type = real_decl_type(spec->type);
345
346 switch (type->type) {
347 case PSI_T_FLOAT:
348 mem->fval = (float) zval_get_double(zv);
349 break;
350 case PSI_T_DOUBLE:
351 mem->dval = zval_get_double(zv);
352 break;
353 case PSI_T_VOID:
354 case PSI_T_INT8:
355 case PSI_T_UINT8:
356 if (spec->var->pointer_level) {
357 zend_string *zs = zval_get_string(zv);
358 *tmp = mem->ptr = estrndup(zs->val, zs->len);
359 zend_string_release(zs);
360 break;
361 }
362 /* no break */
363 default:
364 mem->zend.lval = zval_get_long(zv);
365 break;
366 }
367 }
368
369 void *psi_array_to_struct(decl_struct *s, HashTable *arr)
370 {
371 size_t i, j = 0;
372 char *mem = ecalloc(1, s->size + s->args->count * sizeof(void *));
373
374 if (arr) for (i = 0; i < s->args->count; ++i) {
375 decl_arg *darg = s->args->args[i];
376 zval *entry = zend_hash_str_find_ind(arr, darg->var->name, strlen(darg->var->name));
377
378 if (entry) {
379 impl_val val;
380 void *tmp = NULL;
381
382 memset(&tmp, 0, sizeof(tmp));
383 psi_from_zval(&val, darg, entry, &tmp);
384 memcpy(mem + darg->layout->pos, &val, darg->layout->len);
385 if (tmp) {
386 ((void **)(mem + s->size))[j++] = tmp;
387 }
388 }
389 }
390 return mem;
391 }
392
393 void psi_to_recursive(zval *return_value, set_value *set, impl_val *r_val)
394 {
395 set->outer.set->func->handler(return_value, set, r_val);
396 }
397
398 void psi_to_array(zval *return_value, set_value *set, impl_val *r_val)
399 {
400 size_t i;
401 decl_var *var = set->vars->vars[0];
402 token_t t = real_decl_type(var->arg->type)->type;
403 impl_val tmp, *ret_val = deref_impl_val(r_val, var);
404
405 if ((intptr_t) ret_val <= (intptr_t) 0) {
406 RETURN_NULL();
407 }
408
409 array_init(return_value);
410
411 if (t == PSI_T_STRUCT) {
412 // decl_struct *s = real_decl_type(var->arg->type)->strct;
413
414 if (set->inner && set->inner->count) {
415 /* explicit member casts */
416 for (i = 0; i < set->inner->count; ++i) {
417 set_value *sub_set = set->inner->vals[i];
418 decl_var *sub_var = sub_set->vars->vars[0];
419
420 sub_set->outer.val = ret_val;
421
422 if (sub_var->arg) {
423 impl_val *tmp = NULL, *val;
424 zval ztmp;
425
426 val = struct_member_ref(sub_var->arg, ret_val, &tmp);
427 sub_set->func->handler(&ztmp, sub_set, val);
428 add_assoc_zval(return_value, sub_var->name, &ztmp);
429
430 if (tmp) {
431 free(tmp);
432 }
433 }
434 }
435 }
436 return;
437 }
438
439 if (var->arg->var->array_size) {
440 /* to_array(foo[NUMBER]) */
441 for (i = 0; i < var->arg->var->array_size; ++i) {
442 size_t size = psi_t_size(var->arg->var->pointer_level > 1 ? PSI_T_POINTER : t);
443 impl_val *ptr = iterate(ret_val, size, i, &tmp);
444 zval ele;
445
446 switch (t) {
447 case PSI_T_FLOAT:
448 ZVAL_DOUBLE(&ele, (double) ptr->fval);
449 break;
450 case PSI_T_DOUBLE:
451 ZVAL_DOUBLE(&ele, ptr->dval);
452 break;
453 default:
454 ZVAL_LONG(&ele, ptr->lval);
455 break;
456 }
457
458 add_next_index_zval(return_value, &ele);
459 }
460 return;
461 } else if (set->num) {
462 /* to_array(arr_var, num_expr, to_int(*arr_var)) */
463 zval ele;
464 char *ptr;
465 zend_long i, n = psi_long_num_exp(set->num, set->outer.val);
466 size_t size = psi_t_size(var->arg->var->pointer_level ? PSI_T_POINTER : t);
467 set_value *sub_set = set->inner->vals[0];
468
469 sub_set->outer.val = set->outer.val;
470 for (i = 0; i < n; ++i) {
471 ptr = (char *) ret_val->ptr + i * size;
472 sub_set->func->handler(&ele, sub_set, (void *) ptr);
473 add_next_index_zval(return_value, &ele);
474 }
475 } else {
476 /* to_array(arr_var, to_int(*arr_var)) */
477 zval ele;
478 char *ptr = ret_val->ptr;
479 size_t size = psi_t_size(var->arg->var->pointer_level ? PSI_T_POINTER : t);
480 set_value *sub_set = set->inner->vals[0];
481
482 sub_set->outer.val = set->outer.val;
483 while (*(void **) ptr) {
484 sub_set->func->handler(&ele, sub_set, (void *) ptr);
485 add_next_index_zval(return_value, &ele);
486 ptr += size;
487 }
488 }
489 }
490
491 impl_val *psi_let_arrval(impl_val *tmp, decl_type *type, impl_arg *iarg, void **to_free)
492 {
493 decl_type *real = real_decl_type(type);
494 HashTable *arr;
495
496 if (iarg->type->type != PSI_T_ARRAY) {
497 SEPARATE_ARG_IF_REF(iarg->_zv);
498 convert_to_array(iarg->_zv);
499 }
500 arr = HASH_OF(iarg->_zv);
501
502 switch (real->type) {
503 case PSI_T_STRUCT:
504 *to_free = tmp = psi_array_to_struct(real->real.strct, arr);
505 break;
506 EMPTY_SWITCH_DEFAULT_CASE();
507 }
508
509 return tmp;
510 }
511
512 void psi_to_object(zval *return_value, set_value *set, impl_val *r_val)
513 {
514 decl_var *var = set->vars->vars[0];
515 impl_val *ret_val = deref_impl_val(r_val, var);
516 psi_object *obj;
517
518 if ((intptr_t) ret_val->ptr > (intptr_t) 0) {
519 object_init_ex(return_value, psi_object_get_class_entry());
520 obj = PSI_OBJ(return_value, NULL);
521 obj->data = ret_val->ptr;
522 } else {
523 RETVAL_NULL();
524 }
525 }
526
527 impl_val *psi_let_objval(impl_val *tmp, decl_type *type, impl_arg *iarg, void **to_free)
528 {
529 psi_object *obj;
530
531 if (Z_TYPE_P(iarg->_zv) != IS_OBJECT
532 || !instanceof_function(Z_OBJCE_P(iarg->_zv), psi_object_get_class_entry())) {
533 return NULL;
534 }
535
536 obj = PSI_OBJ(iarg->_zv, NULL);
537 tmp->ptr = obj->data;
538
539 return tmp;
540 }
541
PHP System Interface / POSIX Standard Interface