projects / m6w6 / ext-psi / blob
? search:


37f99766acd63dfda8817084efd173084067703c
[m6w6/ext-psi] / src / engine.c
1 #ifdef HAVE_CONFIG_H
2 # include "config.h"
3 #endif
4
5 #include "php.h"
6 #include "php_psi.h"
7
8 #include "zend_exceptions.h"
9
10 #include "parser.h"
11 #include "engine.h"
12 #include "calc.h"
13 #include "marshal.h"
14
15
16 int psi_internal_type(impl_type *type)
17 {
18 switch (type->type) {
19 case PSI_T_BOOL:
20 return _IS_BOOL;
21 case PSI_T_INT:
22 return IS_LONG;
23 case PSI_T_FLOAT:
24 case PSI_T_DOUBLE:
25 return IS_DOUBLE;
26 case PSI_T_STRING:
27 return IS_STRING;
28 case PSI_T_ARRAY:
29 return IS_ARRAY;
30 default:
31 return 0;
32 }
33 }
34
35 zend_internal_arg_info *psi_internal_arginfo(impl *impl)
36 {
37 size_t i;
38 zend_internal_arg_info *aip;
39 zend_internal_function_info *fi;
40
41 aip = calloc(impl->func->args->count + 1 + !!impl->func->args->vararg.name, sizeof(*aip));
42
43 fi = (zend_internal_function_info *) &aip[0];
44 fi->allow_null = 1;
45 fi->required_num_args = psi_num_min_args(impl);
46 fi->return_reference = impl->func->return_reference;
47 fi->type_hint = psi_internal_type(impl->func->return_type);
48
49 if (impl->func->args->vararg.name) {
50 impl_arg *vararg = impl->func->args->vararg.name;
51 zend_internal_arg_info *ai = &aip[impl->func->args->count];
52
53 ai->name = vararg->var->name;
54 ai->allow_null = 1;
55 ai->type_hint = psi_internal_type(vararg->type);
56 if (vararg->var->reference) {
57 ai->pass_by_reference = 1;
58 }
59 ai->is_variadic = 1;
60 }
61
62 for (i = 0; i < impl->func->args->count; ++i) {
63 impl_arg *iarg = impl->func->args->args[i];
64 zend_internal_arg_info *ai = &aip[i+1];
65
66 ai->name = iarg->var->name;
67 ai->type_hint = psi_internal_type(iarg->type);
68 if (iarg->var->reference) {
69 ai->pass_by_reference = 1;
70 }
71 //if (iarg->var->reference || (iarg->def && iarg->def->type == PSI_T_NULL)) {
72 ai->allow_null = 1;
73 //}
74 }
75
76 return aip;
77 }
78
79 size_t psi_num_min_args(impl *impl)
80 {
81 size_t i, n = impl->func->args->count;
82
83 for (i = 0; i < impl->func->args->count; ++i) {
84 if (impl->func->args->args[i]->def) {
85 --n;
86 }
87 }
88 return n;
89 }
90
91
92 static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, impl *impl)
93 {
94 size_t i;
95 impl_arg *iarg;
96 zend_error_handling zeh;
97
98 zend_replace_error_handling(EH_THROW, zend_exception_get_default(), &zeh);
99
100 if (!impl->func->args->count) {
101 ZEND_RESULT_CODE rv;
102
103 rv = zend_parse_parameters_none();
104 zend_restore_error_handling(&zeh);
105 return rv;
106 }
107
108 ZEND_PARSE_PARAMETERS_START(psi_num_min_args(impl), impl->func->args->vararg.name ? -1 : impl->func->args->count)
109 nextarg:
110 if (impl->func->args->vararg.name && _i >= impl->func->args->count) {
111 impl_arg *varg = impl->func->args->vararg.name;
112 iarg = init_impl_arg(
113 init_impl_type(varg->type->type, varg->type->name),
114 init_impl_var(varg->var->name, varg->var->reference),
115 NULL);
116
117 Z_PARAM_OPTIONAL;
118 if (_i == impl->func->args->count) {
119 impl->func->args->vararg.args = init_impl_args(iarg);
120 } else {
121 add_impl_arg(impl->func->args->vararg.args, iarg);
122 }
123 } else {
124 iarg = impl->func->args->args[_i];
125 if (iarg->def) {
126 Z_PARAM_OPTIONAL;
127 }
128 }
129 if (PSI_T_BOOL == iarg->type->type) {
130 Z_PARAM_BOOL(iarg->val.zend.bval);
131 } else if (PSI_T_INT == iarg->type->type) {
132 Z_PARAM_LONG(iarg->val.zend.lval);
133 } else if (PSI_T_FLOAT == iarg->type->type || PSI_T_DOUBLE == iarg->type->type) {
134 Z_PARAM_DOUBLE(iarg->val.dval);
135 } else if (PSI_T_STRING == iarg->type->type) {
136 Z_PARAM_STR_EX(iarg->val.zend.str, 1, iarg->var->reference);
137 if (iarg->val.zend.str) {
138 zend_string_addref(iarg->val.zend.str);
139 }
140 } else if (PSI_T_ARRAY == iarg->type->type) {
141 Z_PARAM_PROLOGUE(0);
142 } else if (PSI_T_OBJECT == iarg->type->type) {
143 Z_PARAM_PROLOGUE(0);
144 } else if (PSI_T_MIXED == iarg->type->type) {
145 Z_PARAM_PROLOGUE(0);
146 } else if (PSI_T_CALLABLE == iarg->type->type) {
147 zend_fcall_info fci;
148 zend_fcall_info_cache fcc;
149
150 Z_PARAM_FUNC_EX(fci, fcc, 1, 0);
151
152 if (fci.size) {
153 iarg->val.zend.cb = ecalloc(1, sizeof(zend_fcall));
154 iarg->val.zend.cb->fci = fci;
155 iarg->val.zend.cb->fcc = fcc;
156 }
157 } else {
158 error_code = ZPP_ERROR_FAILURE;
159 break;
160 }
161 iarg->_zv = _arg;
162 ZVAL_DEREF(iarg->_zv);
163 if (_i < _num_args) {
164 goto nextarg;
165 }
166 ZEND_PARSE_PARAMETERS_END_EX(
167 zend_restore_error_handling(&zeh);
168 return FAILURE
169 );
170
171 /* set up defaults */
172 for (i = 0; i < impl->func->args->count; ++i) {
173 if (i >= EX_NUM_ARGS() && iarg->def) {
174 iarg = impl->func->args->args[i];
175
176 switch (iarg->type->type) {
177 case PSI_T_BOOL:
178 iarg->val.zend.bval = iarg->def->type == PSI_T_TRUE ? 1 : 0;
179 break;
180 case PSI_T_INT:
181 iarg->val.zend.lval = zend_atol(iarg->def->text, strlen(iarg->def->text));
182 break;
183 case PSI_T_FLOAT:
184 case PSI_T_DOUBLE:
185 iarg->val.dval = zend_strtod(iarg->def->text, NULL);
186 break;
187 case PSI_T_STRING:
188 /* FIXME */
189 iarg->val.zend.str = zend_string_init(&iarg->def->text[1], strlen(iarg->def->text) - 2, 0);
190 break;
191 }
192 }
193 }
194
195 zend_restore_error_handling(&zeh);
196 return SUCCESS;
197 }
198
199 static inline void *psi_do_calloc(let_calloc *alloc)
200 {
201 zend_long n = psi_long_num_exp(alloc->nmemb, NULL), s = psi_long_num_exp(alloc->size, NULL);
202 void *mem = safe_emalloc(n, s, sizeof(void *));
203 memset(mem, 0, n * s + sizeof(void *));
204 #if 0
205 fprintf(stderr, "calloc: %p\n", mem);
206 #endif
207 return mem;
208 }
209
210 static inline impl_val *psi_let_func(let_func *func, decl_arg *darg) {
211 return darg->ptr = func->handler(darg->ptr, darg->type, func->var->arg, &darg->mem);
212 }
213
214 static inline void *psi_do_let(let_stmt *let)
215 {
216 decl_arg *darg = let->var->arg;
217
218 switch (let->val ? let->val->kind : PSI_LET_NULL) {
219 case PSI_LET_TMP:
220 memcpy(darg->ptr, deref_impl_val(let->val->data.var->arg->let, let->val->data.var), sizeof(impl_val));
221 break;
222 case PSI_LET_NULL:
223 if (darg->var->array_size) {
224 darg->val.ptr = ecalloc(darg->var->array_size, sizeof(impl_val));
225 darg->mem = darg->val.ptr;
226 } else {
227 memset(&darg->val, 0, sizeof(impl_val));
228 }
229 break;
230 case PSI_LET_CALLOC:
231 darg->val.ptr = psi_do_calloc(let->val->data.alloc);
232 darg->mem = darg->val.ptr;
233 break;
234 case PSI_LET_CALLBACK:
235 darg->val.ptr = let->val->data.callback->decl->call.sym;
236 break;
237 case PSI_LET_NUMEXP:
238 darg->val.zend.lval = psi_long_num_exp(let->val->data.num, NULL);
239 break;
240 case PSI_LET_FUNC:
241 if (!psi_let_func(let->val->data.func, darg)) {
242 return NULL;
243 }
244 break;
245 }
246
247 if (let->val && let->val->flags.one.is_reference) {
248 return darg->let = &darg->ptr;
249 } else {
250 return darg->let = darg->ptr;
251 }
252 }
253
254 static inline void psi_do_return(zval *return_value, return_stmt *ret)
255 {
256 ret->set->func->handler(return_value, ret->set, ret->set->vars->vars[0]->arg->ptr);
257 }
258
259 static inline void psi_do_free(free_stmt *fre)
260 {
261 size_t i, j;
262
263 for (i = 0; i < fre->calls->count; ++i) {
264 free_call *f = fre->calls->list[i];
265
266 for (j = 0; j < f->vars->count; ++j) {
267 decl_var *dvar = f->vars->vars[j];
268 decl_arg *darg = dvar->arg;
269 impl_val *fval = darg->let;
270
271 f->decl->call.args[j] = deref_impl_val(fval, dvar);
272 }
273
274 /* FIXME: check in validate_* that free functions return scalar */
275 psi_context_call(&PSI_G(context), &f->decl->call, NULL);
276 }
277 }
278
279 static inline void psi_clean_array_struct(let_stmt *let, decl_arg *darg) {
280 if (let->val->kind == PSI_LET_FUNC
281 && let->val->data.func->type == PSI_T_ARRVAL) {
282 decl_type *type = real_decl_type(darg->type);
283
284 if (type->type == PSI_T_STRUCT) {
285 void **ptr = (void **) ((char *) darg->mem + type->real.strct->size);
286
287 while (*ptr) {
288 efree(*ptr++);
289 }
290 } else if (type->type == PSI_T_STRUCT) {
291 void **ptr = (void **) ((char *) darg->mem + type->real.unn->size);
292
293 if (*ptr) {
294 efree(*ptr);
295 }
296 }
297 }
298 }
299
300 static inline void psi_do_clean(impl *impl)
301 {
302 size_t i;
303
304 if (impl->decl->func->ptr != &impl->decl->func->val) {
305 efree(impl->decl->func->ptr);
306 impl->decl->func->ptr = &impl->decl->func->val;
307 }
308
309 for (i = 0; i < impl->func->args->count; ++i ) {
310 impl_arg *iarg = impl->func->args->args[i];
311
312 switch (iarg->type->type) {
313 case PSI_T_STRING:
314 if (iarg->val.zend.str) {
315 zend_string_release(iarg->val.zend.str);
316 }
317 break;
318 case PSI_T_CALLABLE:
319 if (iarg->val.zend.cb) {
320 if (iarg->val.zend.cb->fci.size) {
321 zend_fcall_info_args_clear(&iarg->val.zend.cb->fci, 1);
322 }
323 efree(iarg->val.zend.cb);
324 }
325 break;
326 }
327 }
328
329 for (i = 0; i < impl->stmts->let.count; ++i) {
330 let_stmt *let = impl->stmts->let.list[i];
331 decl_arg *darg = let->var->arg;
332
333 if (darg->mem) {
334 psi_clean_array_struct(let, darg);
335 efree(darg->mem);
336 darg->mem = NULL;
337 }
338 darg->ptr = &darg->val;
339 darg->let = darg->ptr;
340 }
341
342 if (impl->func->args->vararg.args) {
343 free_impl_args(impl->func->args->vararg.args);
344 impl->func->args->vararg.args = NULL;
345 }
346 if (impl->func->args->vararg.types) {
347 efree(impl->func->args->vararg.types);
348 impl->func->args->vararg.types = NULL;
349 }
350 if (impl->func->args->vararg.values) {
351 efree(impl->func->args->vararg.values);
352 impl->func->args->vararg.values = NULL;
353 }
354 if (impl->func->args->vararg.free_list) {
355 void **list = impl->func->args->vararg.free_list;
356
357 while (*list) {
358 efree(*list++);
359 }
360
361 efree(impl->func->args->vararg.free_list);
362 impl->func->args->vararg.free_list = NULL;
363 }
364 }
365
366
367 static inline void psi_do_args(impl *impl) {
368 size_t i;
369
370 for (i = 0; i < impl->decl->args->count; ++i) {
371 impl->decl->call.args[i] = impl->decl->args->args[i]->let;
372 }
373
374 if (!impl->decl->func->var->pointer_level) {
375 decl_type *real = real_decl_type(impl->decl->func->type);
376
377 switch (real->type) {
378 case PSI_T_STRUCT:
379 impl->decl->func->ptr = psi_array_to_struct(real->real.strct, NULL);
380 break;
381 case PSI_T_UNION:
382 impl->decl->func->ptr = psi_array_to_union(real->real.unn, NULL);
383 break;
384 }
385 }
386 }
387
388 static inline impl_vararg *psi_do_varargs(impl *impl) {
389 size_t i, j;
390 impl_vararg *va = &impl->func->args->vararg;
391 size_t vacount = va->args->count;
392
393
394 if (!vacount) {
395 return NULL;
396 }
397
398 va->types = ecalloc(vacount, sizeof(*va->types));
399 va->values = ecalloc(vacount, sizeof(*va->values));
400
401 for (i = 0, j = 0; i < vacount; ++i) {
402 impl_arg *vaarg = va->args->args[i];
403 void *to_free = NULL;
404 token_t vatype = va->name->type->type;
405 let_func_handler let_fn;
406
407 if (vatype == PSI_T_MIXED) {
408 switch (Z_TYPE_P(vaarg->_zv)) {
409 case IS_TRUE:
410 case IS_FALSE: vatype = PSI_T_BOOL; break;
411 case IS_LONG: vatype = PSI_T_INT; break;
412 case IS_DOUBLE: vatype = PSI_T_FLOAT; break;
413 default: vatype = PSI_T_STRING; break;
414 }
415 }
416
417
418 switch (vatype) {
419 case PSI_T_BOOL: let_fn = psi_let_boolval; break;
420 case PSI_T_INT: let_fn = psi_let_intval; break;
421 case PSI_T_FLOAT:
422 case PSI_T_DOUBLE: let_fn = psi_let_floatval; break;
423 case PSI_T_STRING: let_fn = psi_let_strval; break;
424 EMPTY_SWITCH_DEFAULT_CASE();
425 }
426
427 va->types[i] = vatype;
428
429 /* FIXME: varargs with struct-by-value :) */
430 //if (!psi_let_val(let_fn, vaarg, &va->values[i], NULL, &to_free)) {
431 if (!let_fn(&va->values[i], NULL, vaarg, &to_free)) {
432 return NULL;
433 }
434
435 if (to_free) {
436 if (!va->free_list) {
437 va->free_list = ecalloc(vacount - i + 1, sizeof(*va->free_list));
438 }
439 va->free_list[j++] = to_free;
440 }
441 }
442
443 return va;
444 }
445
446 ZEND_RESULT_CODE psi_call(zend_execute_data *execute_data, zval *return_value, impl *impl)
447 {
448 size_t i;
449 impl_vararg *va = NULL;
450
451 memset(impl->decl->func->ptr, 0, sizeof(impl_val));
452
453 if (SUCCESS != psi_parse_args(execute_data, impl)) {
454 return FAILURE;
455 }
456
457 for (i = 0; i < impl->stmts->let.count; ++i) {
458 let_stmt *let = impl->stmts->let.list[i];
459
460 if (!psi_do_let(let)) {
461 psi_do_return(return_value, impl->stmts->ret.list[0]);
462 psi_do_clean(impl);
463 return FAILURE;
464 }
465 }
466
467 if (impl->decl->args) {
468 psi_do_args(impl);
469
470 if (impl->func->args->vararg.args) {
471 va = psi_do_varargs(impl);
472 }
473 }
474
475 psi_context_call(&PSI_G(context), &impl->decl->call, va);
476 psi_do_return(return_value, impl->stmts->ret.list[0]);
477
478 for (i = 0; i < impl->stmts->set.count; ++i) {
479 set_stmt *set = impl->stmts->set.list[i];
480
481 if (set->arg->_zv) {
482 psi_do_set(set->arg->_zv, set->val);
483 }
484 }
485
486 for (i = 0; i < impl->stmts->fre.count; ++i) {
487 free_stmt *fre = impl->stmts->fre.list[i];
488
489 psi_do_free(fre);
490 }
491 psi_do_clean(impl);
492
493 return SUCCESS;
494 }
495
496 ZEND_RESULT_CODE psi_callback(let_callback *cb, void *retval, unsigned argc, void **argv)
497 {
498 size_t i;
499 decl *decl_cb = cb->decl;
500 impl_arg *iarg = cb->func->var->arg;
501 zval return_value, *zargv = calloc(argc, sizeof(*zargv));
502 void *result, *to_free = NULL;
503
504 ZEND_ASSERT(argc == cb->decl->args->count);
505
506 /* prepare args for the userland call */
507 for (i = 0; i < argc; ++i) {
508 cb->decl->args->args[i]->let = argv[i];
509 }
510 for (i = 0; i < cb->args->count; ++i) {
511 psi_do_set(&zargv[i], cb->args->vals[i]);
512 }
513 zend_fcall_info_argp(&iarg->val.zend.cb->fci, cb->args->count, zargv);
514
515 /* callback into userland */
516 ZVAL_UNDEF(&return_value);
517 iarg->_zv = &return_value;
518 zend_fcall_info_call(&iarg->val.zend.cb->fci, &iarg->val.zend.cb->fcc, iarg->_zv, NULL);
519
520 /* marshal return value of the userland call */
521 switch (iarg->type->type) {
522 case PSI_T_BOOL: zend_parse_arg_bool(iarg->_zv, &iarg->val.zend.bval, NULL, 0); break;
523 case PSI_T_LONG: zend_parse_arg_long(iarg->_zv, &iarg->val.zend.lval, NULL, 0, 1); break;
524 case PSI_T_FLOAT:
525 case PSI_T_DOUBLE: zend_parse_arg_double(iarg->_zv, &iarg->val.dval, NULL, 0); break;
526 case PSI_T_STRING: zend_parse_arg_str(iarg->_zv, &iarg->val.zend.str, 0); break;
527 }
528 result = cb->func->handler(retval, decl_cb->func->type, iarg, &to_free);
529
530 if (result != retval) {
531 *(void **)retval = result;
532 }
533
534 zend_fcall_info_args_clear(&iarg->val.zend.cb->fci, 0);
535 for (i = 0; i < cb->args->count; ++i) {
536 zval_ptr_dtor(&zargv[i]);
537 }
538 free(zargv);
539
540 return SUCCESS;
541
542 }
PHP System Interface / POSIX Standard Interface