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