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 *******************************************************************************/
26 #include "php_psi_stdinc.h"
32 #include "zend_exceptions.h"
33 #include "ext/spl/spl_exceptions.h"
35 struct psi_call_frame_argument
*psi_call_frame_argument_init(struct psi_impl_arg
*spec
,
36 impl_val
*ival
, zval
*zptr
, int is_vararg
) {
37 struct psi_call_frame_argument
*frame_arg
= ecalloc(1, sizeof(*frame_arg
));
40 if ((frame_arg
->zval_ptr
= zptr
)) {
41 ZVAL_DEREF(frame_arg
->zval_ptr
);
43 /* use userland type if the declared type of the vararg is mixed */
45 if (spec
->type
->type
== PSI_T_MIXED
) {
46 switch (Z_TYPE_P(zptr
)) {
48 frame_arg
->va_type
= PSI_T_BOOL
;
52 frame_arg
->va_type
= PSI_T_BOOL
;
56 frame_arg
->va_type
= PSI_T_INT
;
57 ival
->zend
.lval
= Z_LVAL_P(zptr
);
60 frame_arg
->va_type
= PSI_T_FLOAT
;
61 ival
->dval
= Z_DVAL_P(zptr
);
64 frame_arg
->va_type
= PSI_T_STRING
;
65 ival
->zend
.str
= zval_get_string(zptr
);
69 frame_arg
->va_type
= spec
->type
->type
;
74 frame_arg
->ival
= *ival
;
75 frame_arg
->ival_ptr
= &frame_arg
->ival
;
76 frame_arg
->spec
= spec
;
81 void psi_call_frame_argument_free(struct psi_call_frame_argument
*arg
) {
82 switch (arg
->spec
->type
->type
) {
84 if (arg
->ival
.zend
.str
) {
85 zend_string_release(arg
->ival
.zend
.str
);
89 if (arg
->ival
.zend
.cb
) {
90 if (arg
->ival
.zend
.cb
->fci
.size
) {
91 zend_fcall_info_args_clear(&arg
->ival
.zend
.cb
->fci
, 1);
93 efree(arg
->ival
.zend
.cb
);
99 if (arg
->ival_ptr
&& arg
->ival_ptr
!= &arg
->temp_val
&& arg
->ival_ptr
!= &arg
->ival
) {
100 efree(arg
->ival_ptr
);
105 struct psi_call_frame_symbol
*psi_call_frame_symbol_init(struct psi_decl_var
*dvar
) {
106 struct psi_call_frame_symbol
*frame_sym
;
107 size_t size
= psi_decl_type_get_size(dvar
->arg
->type
, NULL
);
109 frame_sym
= ecalloc(1, sizeof(*frame_sym
) + size
);
110 frame_sym
->ptr
= frame_sym
->ival_ptr
= &frame_sym
->temp_val
;
115 void psi_call_frame_symbol_free(struct psi_call_frame_symbol
*sym
) {
119 static void psi_call_frame_free_argument(zval
*zptr
) {
120 psi_call_frame_argument_free(Z_PTR_P(zptr
));
123 static void psi_call_frame_free_symbol(zval
*zptr
) {
124 psi_call_frame_symbol_free(Z_PTR_P(zptr
));
127 struct psi_call_frame_auto_free
{
129 void (*dtor
)(void *);
132 static void psi_call_frame_free_temp(void *ptr
) {
133 struct psi_call_frame_auto_free
*f
= ptr
;
144 struct psi_call_frame
*psi_call_frame_init(struct psi_context
*C
, struct psi_decl
*decl
, struct psi_impl
*impl
) {
145 struct psi_call_frame
*frame
= ecalloc(1, sizeof(*frame
));
151 zend_hash_init(&frame
->arguments
, 8, NULL
, psi_call_frame_free_argument
, 0);
152 zend_hash_init(&frame
->symbols
, 8, NULL
, psi_call_frame_free_symbol
, 0);
153 zend_llist_init(&frame
->temp
, sizeof(struct psi_call_frame_auto_free
), psi_call_frame_free_temp
, 0);
158 struct psi_call_frame_symbol
*psi_call_frame_fetch_symbol(
159 struct psi_call_frame
*frame
, struct psi_decl_var
*dvar
) {
160 struct psi_call_frame_symbol
*frame_sym
;
162 frame_sym
= zend_hash_str_find_ptr(&frame
->symbols
, dvar
->fqn
, strlen(dvar
->fqn
));
164 frame_sym
= zend_hash_str_add_ptr(&frame
->symbols
, dvar
->fqn
, strlen(dvar
->fqn
),
165 psi_call_frame_symbol_init(dvar
));
170 zval
*psi_call_frame_new_argument(struct psi_call_frame
*frame
,
171 struct psi_call_frame_argument
*frame_arg
) {
172 if (frame_arg
->va_type
) {
173 /* varargs are just appended with numeric indices */
174 return zend_hash_next_index_insert_ptr(&frame
->arguments
, frame_arg
);
176 return zend_hash_str_add_ptr(&frame
->arguments
,
177 frame_arg
->spec
->var
->name
, strlen(frame_arg
->spec
->var
->name
),
182 zval
*psi_call_frame_sub_argument(struct psi_call_frame
*frame
,
183 struct psi_impl_var
*inner_var
, zval
*outer_zval
, const char *name
) {
184 struct psi_call_frame_argument
*iarg
;
185 zval
*inner_zval
= zend_symtable_str_find(Z_ARRVAL_P(outer_zval
),
186 &inner_var
->name
[1], strlen(&inner_var
->name
[1]));
191 SEPARATE_ZVAL(outer_zval
);
192 ZVAL_NULL(&empty_zval
);
193 inner_zval
= zend_symtable_str_update(Z_ARRVAL_P(outer_zval
),
194 &inner_var
->name
[1], strlen(&inner_var
->name
[1]),
198 iarg
= psi_call_frame_get_argument(frame
, name
);
201 struct psi_call_frame_argument
*frame_arg
;
202 impl_val empty_val
= {0};
203 struct psi_impl_arg
*carg_spec
= psi_impl_arg_init(
204 psi_impl_type_init(PSI_T_MIXED
, "mixed"),
205 psi_impl_var_copy(inner_var
), NULL
);
207 psi_call_frame_push_auto_ex(frame
, carg_spec
, (void(*)(void*)) psi_impl_arg_free
);
208 frame_arg
= psi_call_frame_argument_init(carg_spec
, &empty_val
, inner_zval
, 0);
209 zend_hash_str_add_ptr(&frame
->arguments
, name
, strlen(name
), frame_arg
);
215 struct psi_call_frame_argument
*psi_call_frame_get_argument(
216 struct psi_call_frame
*frame
, const char *name
) {
217 return zend_hash_str_find_ptr(&frame
->arguments
, name
, strlen(name
));
220 size_t psi_call_frame_num_var_args(struct psi_call_frame
*frame
) {
221 return zend_hash_next_free_element(&frame
->arguments
);
224 size_t psi_call_frame_num_fixed_args(struct psi_call_frame
*frame
) {
225 return psi_plist_count(frame
->decl
->args
);
228 struct psi_call_frame_argument
*psi_call_frame_get_var_argument(
229 struct psi_call_frame
*frame
, zend_long index
) {
230 return zend_hash_index_find_ptr(&frame
->arguments
, index
);
233 void **psi_call_frame_get_arg_pointers(struct psi_call_frame
*frame
) {
234 return frame
->pointers
;
237 void *psi_call_frame_get_rpointer(struct psi_call_frame
*frame
) {
238 return frame
->rpointer
;
241 struct psi_decl
*psi_call_frame_get_decl(struct psi_call_frame
*frame
) {
245 struct psi_impl
*psi_call_frame_get_impl(struct psi_call_frame
*frame
) {
249 struct psi_context
*psi_call_frame_get_context(struct psi_call_frame
*frame
) {
250 return frame
->context
;
253 ZEND_RESULT_CODE
psi_call_frame_parse_args(struct psi_call_frame
*frame
,
254 zend_execute_data
*execute_data
) {
255 size_t i
, argc
= psi_plist_count(frame
->impl
->func
->args
);
256 zend_error_handling zeh
;
258 zend_replace_error_handling(EH_THROW
, zend_exception_get_default(), &zeh
);
263 rv
= zend_parse_parameters_none();
264 zend_restore_error_handling(&zeh
);
268 ZEND_PARSE_PARAMETERS_START(
269 psi_impl_num_min_args(frame
->impl
),
270 frame
->impl
->func
->vararg
? -1 : argc
274 struct psi_impl_arg
*iarg
;
277 if (frame
->impl
->func
->vararg
&& _i
>= argc
) {
278 iarg
= frame
->impl
->func
->vararg
;
281 psi_plist_get(frame
->impl
->func
->args
, _i
, &iarg
);
287 if (PSI_T_BOOL
== iarg
->type
->type
) {
288 Z_PARAM_BOOL(ival
.zend
.bval
);
289 } else if (PSI_T_INT
== iarg
->type
->type
) {
290 Z_PARAM_LONG(ival
.zend
.lval
);
291 } else if (PSI_T_FLOAT
== iarg
->type
->type
|| PSI_T_DOUBLE
== iarg
->type
->type
) {
292 Z_PARAM_DOUBLE(ival
.dval
);
293 } else if (PSI_T_STRING
== iarg
->type
->type
) {
294 Z_PARAM_STR_EX(ival
.zend
.str
, 1, iarg
->var
->reference
);
296 zend_string_addref(ival
.zend
.str
);
298 } else if (PSI_T_ARRAY
== iarg
->type
->type
) {
300 Z_PARAM_ARRAY_EX(tmp
, _optional
|| iarg
->var
->reference
,
301 iarg
->var
->reference
);
302 } else if (PSI_T_OBJECT
== iarg
->type
->type
) {
303 Z_PARAM_PROLOGUE(iarg
->var
->reference
);
304 } else if (PSI_T_MIXED
== iarg
->type
->type
) {
305 Z_PARAM_PROLOGUE(iarg
->var
->reference
);
306 } else if (PSI_T_CALLABLE
== iarg
->type
->type
) {
308 zend_fcall_info_cache fcc
;
310 Z_PARAM_FUNC_EX(fci
, fcc
, 1, 0);
313 ival
.zend
.cb
= ecalloc(1, sizeof(zend_fcall
));
314 ival
.zend
.cb
->fci
= fci
;
315 ival
.zend
.cb
->fcc
= fcc
;
318 error_code
= ZPP_ERROR_FAILURE
;
322 psi_call_frame_new_argument(frame
,
323 psi_call_frame_argument_init(iarg
, &ival
, _arg
, _i
> argc
));
325 if (_i
< _num_args
) {
329 ZEND_PARSE_PARAMETERS_END_EX(
330 zend_restore_error_handling(&zeh
);
334 /* set up defaults */
335 for (i
= EX_NUM_ARGS(); i
< argc
; ++i
) {
336 struct psi_impl_arg
*iarg
;
338 psi_plist_get(frame
->impl
->func
->args
, i
, &iarg
);
341 psi_call_frame_new_argument(frame
, psi_call_frame_argument_init(iarg
,
342 &iarg
->def
->ival
, NULL
, 0));
345 zend_restore_error_handling(&zeh
);
349 void psi_call_frame_enter(struct psi_call_frame
*frame
) {
350 size_t argc
= psi_call_frame_num_fixed_args(frame
);
351 size_t va_count
= psi_call_frame_num_var_args(frame
);
352 size_t rsize
= psi_decl_arg_get_size(frame
->decl
->func
);
353 struct psi_call_frame_symbol
*rv_sym
;
355 /* initialize ffi argument array */
356 frame
->pointers
= ecalloc(argc
+ va_count
+ 1, sizeof(void *));
358 /* initialize return value symbol */
359 rv_sym
= psi_call_frame_fetch_symbol(frame
, frame
->decl
->func
->var
);
360 if (rsize
> sizeof(impl_val
)) {
361 rv_sym
->ival_ptr
= ecalloc(1, rsize
);
363 rv_sym
->ival_ptr
= &rv_sym
->temp_val
;
365 frame
->rpointer
= rv_sym
->ptr
= rv_sym
->ival_ptr
;
368 ZEND_RESULT_CODE
psi_call_frame_do_let(struct psi_call_frame
*frame
) {
370 struct psi_let_stmt
*let
;
371 struct psi_decl_arg
*arg
;
372 size_t argc
= psi_call_frame_num_fixed_args(frame
);
373 size_t va_count
= psi_call_frame_num_var_args(frame
);
375 for (i
= 0; psi_plist_get(frame
->impl
->stmts
.let
, i
, &let
); ++i
) {
376 psi_let_stmt_exec(let
, frame
);
378 for (i
= 0; psi_plist_get(frame
->decl
->args
, i
, &arg
); ++i
) {
379 struct psi_let_stmt
*let
;
380 struct psi_call_frame_symbol
*frame_sym
;
382 let
= psi_impl_get_let(frame
->impl
, arg
->var
);
383 frame_sym
= psi_call_frame_fetch_symbol(frame
, let
->exp
->var
);
384 frame
->pointers
[i
] = frame_sym
->ptr
;
388 for (i
= 0; i
< va_count
; ++i
) {
389 struct psi_call_frame_argument
*frame_arg
;
390 psi_marshal_let let_fn
;
393 frame_arg
= psi_call_frame_get_var_argument(frame
, i
);
394 switch (frame_arg
->va_type
) {
395 case PSI_T_BOOL
: let_fn
= psi_let_boolval
; break;
396 case PSI_T_INT
: let_fn
= psi_let_intval
; break;
398 case PSI_T_DOUBLE
: let_fn
= psi_let_floatval
; break;
399 case PSI_T_STRING
: let_fn
= psi_let_strval
; break;
404 frame_arg
->ival_ptr
= let_fn(&frame_arg
->temp_val
, NULL
, frame_arg
->va_type
,
405 &frame_arg
->ival
, frame_arg
->zval_ptr
, &temp
);
407 psi_call_frame_push_auto(frame
, temp
);
410 frame
->pointers
[argc
+ i
] = frame_arg
->ival_ptr
;
417 ZEND_RESULT_CODE
psi_call_frame_do_assert(struct psi_call_frame
*frame
, enum psi_assert_kind kind
) {
419 struct psi_assert_stmt
*ass
;
421 while (psi_plist_get(frame
->impl
->stmts
.ass
, i
++, &ass
)) {
422 if (ass
->kind
== kind
) {
423 if (!psi_assert_stmt_exec(ass
, frame
)) {
424 char *message
= psi_assert_stmt_message(ass
);
425 zend_throw_exception(kind
== PSI_ASSERT_PRE
426 ? spl_ce_InvalidArgumentException
427 : spl_ce_UnexpectedValueException
, message
, 0);
437 void psi_call_frame_do_call(struct psi_call_frame
*frame
) {
438 frame
->context
->ops
->call(frame
);
441 void psi_call_frame_do_callback(struct psi_call_frame
*frame
, struct psi_call_frame_callback
*cbdata
)
446 struct psi_let_callback
*cb
= cbdata
->cb
->data
.callback
;
447 zval return_value
, *zargv
= ecalloc(cbdata
->argc
, sizeof(*zargv
));
448 struct psi_call_frame_argument
*frame_arg
;
450 assert(cbdata
->argc
== psi_plist_count(cb
->decl
->args
));
452 /* prepare args for the userland call */
453 for (i
= 0; i
< cbdata
->argc
; ++i
) {
454 struct psi_set_exp
*set_exp
;
455 struct psi_decl_var
*set_var
;
456 struct psi_call_frame_symbol
*set_sym
;
458 psi_plist_get(cb
->args
, i
, &set_exp
);
459 set_var
= psi_set_exp_get_decl_var(set_exp
);
460 set_sym
= psi_call_frame_fetch_symbol(frame
, set_var
);
462 set_sym
->ptr
= cbdata
->argv
[i
];
463 psi_set_exp_exec_ex(set_exp
, &zargv
[i
], set_sym
->ptr
, frame
);
466 frame_arg
= psi_call_frame_get_argument(frame
, cb
->func
->var
->fqn
);
468 /* callback into userland */
469 ZVAL_UNDEF(&return_value
);
470 zend_fcall_info_argp(&frame_arg
->ival_ptr
->zend
.cb
->fci
, cbdata
->argc
, zargv
);
471 rc
= zend_fcall_info_call(&frame_arg
->ival_ptr
->zend
.cb
->fci
,
472 &frame_arg
->ival_ptr
->zend
.cb
->fcc
, &return_value
, NULL
);
473 assert(rc
== SUCCESS
);
475 /* marshal return value of the userland call */
476 frame_arg
->zval_ptr
= &return_value
;
477 retptr
= psi_let_func_exec(cbdata
->cb
, cb
->func
, cb
->decl
->func
, frame
);
478 memcpy(cbdata
->rval
, retptr
, psi_decl_arg_get_size(cb
->decl
->func
));
481 zend_fcall_info_args_clear(&frame_arg
->ival_ptr
->zend
.cb
->fci
, 0);
482 for (i
= 0; i
< cbdata
->argc
; ++i
) {
483 zval_ptr_dtor(&zargv
[i
]);
488 void psi_call_frame_do_return(struct psi_call_frame
*frame
, zval
*return_value
) {
489 struct psi_return_stmt
*ret
;
491 psi_plist_get(frame
->impl
->stmts
.ret
, 0, &ret
);
492 psi_return_stmt_exec(ret
, return_value
, frame
);
495 void psi_call_frame_do_set(struct psi_call_frame
*frame
) {
497 struct psi_set_stmt
*set
;
499 while (psi_plist_get(frame
->impl
->stmts
.set
, i
++, &set
)) {
500 psi_set_stmt_exec(set
, frame
);
504 void psi_call_frame_do_free(struct psi_call_frame
*frame
) {
506 struct psi_free_stmt
*fre
;
508 while (psi_plist_get(frame
->impl
->stmts
.fre
, i
++, &fre
)) {
509 psi_free_stmt_exec(fre
, frame
);
513 void **psi_call_frame_push_auto_ex(struct psi_call_frame
*frame
, void *auto_free
, void (*dtor
)(void*)) {
514 struct psi_call_frame_auto_free f
;
519 zend_llist_add_element(&frame
->temp
, &f
);
520 return &((struct psi_call_frame_auto_free
*) zend_llist_get_last(&frame
->temp
))->data
;
523 void **psi_call_frame_push_auto(struct psi_call_frame
*frame
, void *auto_free
) {
524 return psi_call_frame_push_auto_ex(frame
, auto_free
, NULL
);
527 static void psi_call_frame_local_auto_dtor(void *auto_list
)
529 zend_llist_destroy(auto_list
);
535 void psi_call_frame_free(struct psi_call_frame
*frame
) {
536 zend_hash_destroy(&frame
->arguments
);
537 zend_hash_destroy(&frame
->symbols
);
538 if (frame
->impl
&& frame
->impl
->func
->static_memory
) {
539 zend_llist
*temp
= emalloc(sizeof(*temp
));
542 memcpy(temp
, &frame
->temp
, sizeof(*temp
));
543 ZVAL_OBJ(&zlocal
, psi_object_init_ex(NULL
, temp
, psi_call_frame_local_auto_dtor
));
544 zend_set_local_var_str(frame
->impl
->func
->name
,
545 strlen(frame
->impl
->func
->name
), &zlocal
, /* force */ 1);
547 zend_llist_destroy(&frame
->temp
);
549 efree(frame
->pointers
);