1 /*******************************************************************************
2 Copyright (c) 2016, Michael Wallner <mike@php.net>.
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
8 * Redistributions of source code must retain the above copyright notice,
9 this list of conditions and the following disclaimer.
10 * Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the distribution.
14 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
18 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *******************************************************************************/
29 # include "php_config.h"
36 #include "zend_exceptions.h"
38 struct psi_call_frame_argument
*psi_call_frame_argument_init(struct psi_impl_arg
*spec
,
39 impl_val
*ival
, zval
*zptr
, int is_vararg
) {
40 struct psi_call_frame_argument
*frame_arg
= ecalloc(1, sizeof(*frame_arg
));
43 if ((frame_arg
->zval_ptr
= zptr
)) {
44 ZVAL_DEREF(frame_arg
->zval_ptr
);
46 /* use userland type if the declared type of the vararg is mixed */
48 if (spec
->type
->type
== PSI_T_MIXED
) {
49 switch (Z_TYPE_P(zptr
)) {
51 frame_arg
->va_type
= PSI_T_BOOL
;
55 frame_arg
->va_type
= PSI_T_BOOL
;
59 frame_arg
->va_type
= PSI_T_INT
;
60 ival
->zend
.lval
= Z_LVAL_P(zptr
);
63 frame_arg
->va_type
= PSI_T_FLOAT
;
64 ival
->dval
= Z_DVAL_P(zptr
);
67 frame_arg
->va_type
= PSI_T_STRING
;
68 ival
->zend
.str
= zval_get_string(zptr
);
72 frame_arg
->va_type
= spec
->type
->type
;
77 frame_arg
->ival
= *ival
;
78 frame_arg
->ival_ptr
= &frame_arg
->ival
;
79 frame_arg
->spec
= spec
;
84 void psi_call_frame_argument_free(struct psi_call_frame_argument
*arg
) {
85 switch (arg
->spec
->type
->type
) {
87 if (arg
->ival
.zend
.str
) {
88 zend_string_release(arg
->ival
.zend
.str
);
92 if (arg
->ival
.zend
.cb
) {
93 if (arg
->ival
.zend
.cb
->fci
.size
) {
94 zend_fcall_info_args_clear(&arg
->ival
.zend
.cb
->fci
, 1);
96 efree(arg
->ival
.zend
.cb
);
102 if (arg
->ival_ptr
&& arg
->ival_ptr
!= &arg
->temp_val
&& arg
->ival_ptr
!= &arg
->ival
) {
103 efree(arg
->ival_ptr
);
108 struct psi_call_frame_symbol
*psi_call_frame_symbol_init(struct psi_decl_var
*dvar
) {
109 struct psi_call_frame_symbol
*frame_sym
;
110 size_t size
= psi_decl_type_get_size(dvar
->arg
->type
, NULL
);
112 frame_sym
= ecalloc(1, sizeof(*frame_sym
) + size
);
113 frame_sym
->ptr
= frame_sym
->ival_ptr
= &frame_sym
->temp_val
;
118 void psi_call_frame_symbol_free(struct psi_call_frame_symbol
*sym
) {
122 static void psi_call_frame_free_argument(zval
*zptr
) {
123 psi_call_frame_argument_free(Z_PTR_P(zptr
));
126 static void psi_call_frame_free_symbol(zval
*zptr
) {
127 psi_call_frame_symbol_free(Z_PTR_P(zptr
));
130 struct psi_call_frame_auto_free
{
132 void (*dtor
)(void *);
135 static void psi_call_frame_free_temp(void *ptr
) {
136 struct psi_call_frame_auto_free
*f
= ptr
;
147 struct psi_call_frame
*psi_call_frame_init(struct psi_context
*C
, struct psi_decl
*decl
, struct psi_impl
*impl
) {
148 struct psi_call_frame
*frame
= ecalloc(1, sizeof(*frame
));
154 zend_hash_init(&frame
->arguments
, 8, NULL
, psi_call_frame_free_argument
, 0);
155 zend_hash_init(&frame
->symbols
, 8, NULL
, psi_call_frame_free_symbol
, 0);
156 zend_llist_init(&frame
->temp
, sizeof(struct psi_call_frame_auto_free
), psi_call_frame_free_temp
, 0);
161 struct psi_call_frame_symbol
*psi_call_frame_fetch_symbol(
162 struct psi_call_frame
*frame
, struct psi_decl_var
*dvar
) {
163 struct psi_call_frame_symbol
*frame_sym
;
165 frame_sym
= zend_hash_find_ptr(&frame
->symbols
, dvar
->fqn
);
167 frame_sym
= zend_hash_add_ptr(&frame
->symbols
, dvar
->fqn
,
168 psi_call_frame_symbol_init(dvar
));
173 zval
*psi_call_frame_new_argument(struct psi_call_frame
*frame
,
174 struct psi_call_frame_argument
*frame_arg
) {
175 if (frame_arg
->va_type
) {
176 /* varargs are just appended with numeric indices */
177 return zend_hash_next_index_insert_ptr(&frame
->arguments
, frame_arg
);
179 return zend_hash_add_ptr(&frame
->arguments
,
180 frame_arg
->spec
->var
->name
, frame_arg
);
184 zval
*psi_call_frame_sub_argument(struct psi_call_frame
*frame
,
185 struct psi_impl_var
*inner_var
, zval
*outer_zval
, zend_string
*name
) {
186 struct psi_call_frame_argument
*iarg
;
187 zval
*inner_zval
= zend_symtable_str_find(Z_ARRVAL_P(outer_zval
),
188 &inner_var
->name
->val
[1], inner_var
->name
->len
- 1);
193 SEPARATE_ZVAL(outer_zval
);
194 ZVAL_NULL(&empty_zval
);
195 inner_zval
= zend_symtable_str_update(Z_ARRVAL_P(outer_zval
),
196 &inner_var
->name
->val
[1], inner_var
->name
->len
- 1,
200 iarg
= psi_call_frame_get_argument(frame
, name
);
203 struct psi_call_frame_argument
*frame_arg
;
204 impl_val empty_val
= {0};
205 zend_string
*type_str
= psi_string_init_interned(ZEND_STRL("mixed"), 1);
206 struct psi_impl_arg
*carg_spec
= psi_impl_arg_init(
207 psi_impl_type_init(PSI_T_MIXED
, type_str
),
208 psi_impl_var_copy(inner_var
), NULL
);
210 psi_call_frame_push_auto_ex(frame
, carg_spec
, (void(*)(void*)) psi_impl_arg_free
);
211 frame_arg
= psi_call_frame_argument_init(carg_spec
, &empty_val
, inner_zval
, 0);
212 zend_hash_add_ptr(&frame
->arguments
, name
, frame_arg
);
213 zend_string_release(type_str
);
219 struct psi_call_frame_argument
*psi_call_frame_get_argument(
220 struct psi_call_frame
*frame
, zend_string
*name
) {
221 return zend_hash_find_ptr(&frame
->arguments
, name
);
224 size_t psi_call_frame_num_var_args(struct psi_call_frame
*frame
) {
225 return zend_hash_next_free_element(&frame
->arguments
);
228 size_t psi_call_frame_num_fixed_args(struct psi_call_frame
*frame
) {
229 return psi_plist_count(frame
->decl
->args
);
232 struct psi_call_frame_argument
*psi_call_frame_get_var_argument(
233 struct psi_call_frame
*frame
, zend_long index
) {
234 return zend_hash_index_find_ptr(&frame
->arguments
, index
);
237 void **psi_call_frame_get_arg_pointers(struct psi_call_frame
*frame
) {
238 return frame
->pointers
;
241 void *psi_call_frame_get_rpointer(struct psi_call_frame
*frame
) {
242 return frame
->rpointer
;
245 struct psi_decl
*psi_call_frame_get_decl(struct psi_call_frame
*frame
) {
249 struct psi_impl
*psi_call_frame_get_impl(struct psi_call_frame
*frame
) {
253 struct psi_context
*psi_call_frame_get_context(struct psi_call_frame
*frame
) {
254 return frame
->context
;
257 #if PHP_VERSION_ID < 70300
258 # define PARAM_PROLOGUE(separate) Z_PARAM_PROLOGUE(separate)
260 # define PARAM_PROLOGUE(separate) Z_PARAM_PROLOGUE(1, separate)
262 ZEND_RESULT_CODE
psi_call_frame_parse_args(struct psi_call_frame
*frame
,
263 zend_execute_data
*execute_data
) {
264 size_t i
, argc
= psi_plist_count(frame
->impl
->func
->args
);
265 zend_error_handling zeh
;
267 zend_replace_error_handling(EH_THROW
, zend_exception_get_default(), &zeh
);
272 rv
= zend_parse_parameters_none();
273 zend_restore_error_handling(&zeh
);
277 ZEND_PARSE_PARAMETERS_START(
278 psi_impl_num_min_args(frame
->impl
),
279 frame
->impl
->func
->vararg
? -1 : argc
283 struct psi_impl_arg
*iarg
;
286 if (frame
->impl
->func
->vararg
&& _i
>= argc
) {
287 iarg
= frame
->impl
->func
->vararg
;
290 psi_plist_get(frame
->impl
->func
->args
, _i
, &iarg
);
296 if (PSI_T_BOOL
== iarg
->type
->type
) {
297 Z_PARAM_BOOL(ival
.zend
.bval
);
298 } else if (PSI_T_INT
== iarg
->type
->type
) {
299 Z_PARAM_LONG(ival
.zend
.lval
);
300 } else if (PSI_T_FLOAT
== iarg
->type
->type
|| PSI_T_DOUBLE
== iarg
->type
->type
) {
301 Z_PARAM_DOUBLE(ival
.dval
);
302 } else if (PSI_T_STRING
== iarg
->type
->type
) {
303 Z_PARAM_STR_EX(ival
.zend
.str
, 1, iarg
->var
->reference
);
305 zend_string_addref(ival
.zend
.str
);
307 } else if (PSI_T_ARRAY
== iarg
->type
->type
) {
309 Z_PARAM_ARRAY_EX(tmp
, _optional
|| iarg
->var
->reference
,
310 iarg
->var
->reference
);
311 } else if (PSI_T_OBJECT
== iarg
->type
->type
) {
312 PARAM_PROLOGUE(iarg
->var
->reference
);
313 } else if (PSI_T_MIXED
== iarg
->type
->type
) {
314 PARAM_PROLOGUE(iarg
->var
->reference
);
315 } else if (PSI_T_CALLABLE
== iarg
->type
->type
) {
317 zend_fcall_info_cache fcc
;
319 Z_PARAM_FUNC_EX(fci
, fcc
, 1, 0);
322 ival
.zend
.cb
= ecalloc(1, sizeof(zend_fcall
));
323 ival
.zend
.cb
->fci
= fci
;
324 ival
.zend
.cb
->fcc
= fcc
;
327 error_code
= ZPP_ERROR_FAILURE
;
331 psi_call_frame_new_argument(frame
,
332 psi_call_frame_argument_init(iarg
, &ival
, _arg
, _i
> argc
));
334 if (_i
< _num_args
) {
338 ZEND_PARSE_PARAMETERS_END_EX(
339 zend_restore_error_handling(&zeh
);
343 /* set up defaults */
344 for (i
= EX_NUM_ARGS(); i
< argc
; ++i
) {
345 struct psi_impl_arg
*iarg
;
347 psi_plist_get(frame
->impl
->func
->args
, i
, &iarg
);
350 psi_call_frame_new_argument(frame
, psi_call_frame_argument_init(iarg
,
351 &iarg
->def
->ival
, NULL
, 0));
354 zend_restore_error_handling(&zeh
);
358 void psi_call_frame_enter(struct psi_call_frame
*frame
) {
359 size_t argc
= psi_call_frame_num_fixed_args(frame
);
360 size_t va_count
= psi_call_frame_num_var_args(frame
);
361 size_t rsize
= psi_decl_arg_get_size(frame
->decl
->func
);
362 struct psi_call_frame_symbol
*rv_sym
;
364 /* initialize ffi argument array */
365 frame
->pointers
= ecalloc(argc
+ va_count
+ 1, sizeof(void *));
367 /* initialize return value symbol */
368 rv_sym
= psi_call_frame_fetch_symbol(frame
, frame
->decl
->func
->var
);
369 if (rsize
> sizeof(impl_val
)) {
370 rv_sym
->ival_ptr
= ecalloc(1, rsize
);
372 rv_sym
->ival_ptr
= &rv_sym
->temp_val
;
374 frame
->rpointer
= rv_sym
->ptr
= rv_sym
->ival_ptr
;
377 ZEND_RESULT_CODE
psi_call_frame_do_let(struct psi_call_frame
*frame
) {
379 struct psi_let_stmt
*let
;
380 struct psi_decl_arg
*arg
;
381 size_t argc
= psi_call_frame_num_fixed_args(frame
);
382 size_t va_count
= psi_call_frame_num_var_args(frame
);
384 for (i
= 0; psi_plist_get(frame
->impl
->stmts
.let
, i
, &let
); ++i
) {
385 psi_let_stmt_exec(let
, frame
);
387 for (i
= 0; psi_plist_get(frame
->decl
->args
, i
, &arg
); ++i
) {
388 struct psi_let_stmt
*let
;
389 struct psi_call_frame_symbol
*frame_sym
;
391 let
= psi_impl_get_let(frame
->impl
, arg
->var
);
392 frame_sym
= psi_call_frame_fetch_symbol(frame
, let
->exp
->var
);
393 frame
->pointers
[i
] = frame_sym
->ptr
;
397 for (i
= 0; i
< va_count
; ++i
) {
398 struct psi_call_frame_argument
*frame_arg
;
399 psi_marshal_let let_fn
;
402 frame_arg
= psi_call_frame_get_var_argument(frame
, i
);
403 switch (frame_arg
->va_type
) {
404 case PSI_T_BOOL
: let_fn
= psi_let_boolval
; break;
405 case PSI_T_INT
: let_fn
= psi_let_intval
; break;
407 case PSI_T_DOUBLE
: let_fn
= psi_let_floatval
; break;
408 case PSI_T_STRING
: let_fn
= psi_let_strval
; break;
413 frame_arg
->ival_ptr
= let_fn(&frame_arg
->temp_val
, NULL
, frame_arg
->va_type
,
414 &frame_arg
->ival
, frame_arg
->zval_ptr
, &temp
);
416 psi_call_frame_push_auto(frame
, temp
);
419 frame
->pointers
[argc
+ i
] = frame_arg
->ival_ptr
;
426 ZEND_RESULT_CODE
psi_call_frame_do_assert(struct psi_call_frame
*frame
, enum psi_assert_kind kind
) {
428 struct psi_assert_stmt
*ass
;
430 while (psi_plist_get(frame
->impl
->stmts
.ass
, i
++, &ass
)) {
431 if (ass
->kind
== kind
) {
432 if (!psi_assert_stmt_exec(ass
, frame
)) {
433 psi_assert_stmt_throw(ass
);
442 void psi_call_frame_do_call(struct psi_call_frame
*frame
) {
443 frame
->context
->ops
->call(frame
);
446 void psi_call_frame_do_callback(struct psi_call_frame
*frame
, struct psi_call_frame_callback
*cbdata
)
451 struct psi_let_callback
*cb
= cbdata
->cb
->data
.callback
;
452 zval return_value
, *zargv
= ecalloc(cbdata
->argc
, sizeof(*zargv
));
453 struct psi_call_frame_argument
*frame_arg
;
455 assert(cbdata
->argc
== psi_plist_count(cb
->decl
->args
));
457 /* prepare args for the userland call */
458 for (i
= 0; i
< cbdata
->argc
; ++i
) {
459 struct psi_set_exp
*set_exp
;
460 struct psi_decl_var
*set_var
;
461 struct psi_call_frame_symbol
*set_sym
;
463 psi_plist_get(cb
->args
, i
, &set_exp
);
464 set_var
= psi_set_exp_get_decl_var(set_exp
);
465 set_sym
= psi_call_frame_fetch_symbol(frame
, set_var
);
467 set_sym
->ptr
= cbdata
->argv
[i
];
468 psi_set_exp_exec_ex(set_exp
, &zargv
[i
], set_sym
->ptr
, frame
);
471 frame_arg
= psi_call_frame_get_argument(frame
, cb
->func
->var
->fqn
);
473 /* callback into userland */
474 ZVAL_UNDEF(&return_value
);
475 zend_fcall_info_argp(&frame_arg
->ival_ptr
->zend
.cb
->fci
, cbdata
->argc
, zargv
);
476 rc
= zend_fcall_info_call(&frame_arg
->ival_ptr
->zend
.cb
->fci
,
477 &frame_arg
->ival_ptr
->zend
.cb
->fcc
, &return_value
, NULL
);
478 assert(rc
== SUCCESS
);
481 /* marshal return value of the userland call */
482 frame_arg
->zval_ptr
= &return_value
;
483 retptr
= psi_let_func_exec(cbdata
->cb
, cb
->func
, cb
->decl
->func
, frame
);
484 memcpy(cbdata
->rval
, retptr
, psi_decl_arg_get_size(cb
->decl
->func
));
487 zend_fcall_info_args_clear(&frame_arg
->ival_ptr
->zend
.cb
->fci
, 0);
488 for (i
= 0; i
< cbdata
->argc
; ++i
) {
489 zval_ptr_dtor(&zargv
[i
]);
494 void psi_call_frame_do_return(struct psi_call_frame
*frame
, zval
*return_value
) {
495 struct psi_return_stmt
*ret
;
497 psi_plist_get(frame
->impl
->stmts
.ret
, 0, &ret
);
498 psi_return_stmt_exec(ret
, return_value
, frame
);
501 void psi_call_frame_do_set(struct psi_call_frame
*frame
) {
503 struct psi_set_stmt
*set
;
505 while (psi_plist_get(frame
->impl
->stmts
.set
, i
++, &set
)) {
506 psi_set_stmt_exec(set
, frame
);
510 void psi_call_frame_do_free(struct psi_call_frame
*frame
) {
512 struct psi_free_stmt
*fre
;
514 while (psi_plist_get(frame
->impl
->stmts
.fre
, i
++, &fre
)) {
515 psi_free_stmt_exec(fre
, frame
);
519 void **psi_call_frame_push_auto_ex(struct psi_call_frame
*frame
, void *auto_free
, void (*dtor
)(void*)) {
520 struct psi_call_frame_auto_free f
;
525 zend_llist_add_element(&frame
->temp
, &f
);
526 return &((struct psi_call_frame_auto_free
*) zend_llist_get_last(&frame
->temp
))->data
;
529 void **psi_call_frame_push_auto(struct psi_call_frame
*frame
, void *auto_free
) {
530 return psi_call_frame_push_auto_ex(frame
, auto_free
, NULL
);
533 static void psi_call_frame_local_auto_dtor(void *auto_list
)
535 zend_llist_destroy(auto_list
);
541 void psi_call_frame_free(struct psi_call_frame
*frame
) {
542 zend_hash_destroy(&frame
->arguments
);
543 zend_hash_destroy(&frame
->symbols
);
544 if (frame
->impl
&& frame
->impl
->func
->static_memory
) {
545 zend_llist
*temp
= emalloc(sizeof(*temp
));
548 memcpy(temp
, &frame
->temp
, sizeof(*temp
));
549 ZVAL_OBJ(&zlocal
, psi_object_init_ex(NULL
, temp
, psi_call_frame_local_auto_dtor
));
550 zend_set_local_var(frame
->impl
->func
->name
, &zlocal
, /* force */ 1);
552 zend_llist_destroy(&frame
->temp
);
554 efree(frame
->pointers
);