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"
35 struct psi_let_func
*psi_let_func_init(token_t type
, const char *name
,
36 struct psi_impl_var
*var
)
38 struct psi_let_func
*func
= calloc(1, sizeof(*func
));
40 func
->name
= strdup(name
);
45 void psi_let_func_free(struct psi_let_func
**func_ptr
)
48 struct psi_let_func
*func
= *func_ptr
;
54 psi_impl_var_free(&func
->var
);
57 psi_plist_free(func
->inner
);
63 void psi_let_func_dump(int fd
, struct psi_let_func
*func
, unsigned level
)
65 dprintf(fd
, "%s(%s\t/* fqn=%s */", func
->name
, func
->var
->name
, func
->var
->fqn
);
68 size_t i
= 0, count
= psi_plist_count(func
->inner
);
69 struct psi_let_exp
*inner
;
73 while (psi_plist_get(func
->inner
, i
++, &inner
)) {
75 psi_let_exp_dump(fd
, inner
, level
, i
== count
);
79 dprintf(fd
, "%s", psi_t_indent(level
));
84 static inline int validate_let_func_type(struct psi_data
*data
,
85 struct psi_let_func
*func
, struct psi_impl
*impl
)
102 data
->error(data
, func
->token
, PSI_WARNING
,
103 "Expected sub-expressions in `arrval` expression");
109 data
->error(data
, func
->var
->token
, PSI_WARNING
,
110 "Unknown `let` cast function '%s' of implementation '%s'",
111 func
->name
, impl
->func
->name
);
116 static inline bool validate_let_func_inner(struct psi_data
*data
,
117 struct psi_let_exp
*exp
, struct psi_let_func
*func
,
118 struct psi_impl
*impl
)
121 struct psi_decl_var
*let_var
= psi_let_exp_get_decl_var(exp
);
122 struct psi_decl_type
*var_typ
;
123 struct psi_plist
*sub_args
;
125 sub_args
= psi_decl_type_get_args(let_var
->arg
->type
, &var_typ
);
127 if (func
->type
== PSI_T_ARRVAL
&& sub_args
) {
128 /* struct = arrval($array,
129 * member = strval($member) ...)
132 struct psi_let_exp
*inner
;
134 while (psi_plist_get(func
->inner
, i
++, &inner
)) {
135 const char *name
= psi_let_exp_get_decl_var_name(inner
);
136 struct psi_decl_arg
*sub_arg
;
141 sub_arg
= psi_decl_arg_get_by_name(sub_args
, name
);
143 if (!name
|| !sub_arg
) {
144 /* remove expr for portability with different struct members */
145 psi_plist_del(func
->inner
, --i
, NULL
);
146 psi_let_exp_free(&inner
);
147 } else if (!psi_let_exp_validate(data
, inner
, impl
)) {
151 } else if (func
->type
== PSI_T_ARRVAL
152 && psi_plist_count(func
->inner
) == 1
153 && let_var
->arg
->var
->pointer_level
) {
154 /* array = arrval($array,
155 * strval($array)) // cast foreach entry
157 struct psi_let_exp
*inner
;
158 struct psi_impl_var
*sub_var
;
159 struct psi_impl_var
*sub_ref
;
161 psi_plist_get(func
->inner
, 0, &inner
);
164 sub_var
= psi_let_exp_get_impl_var(exp
);
165 sub_ref
= psi_let_exp_get_impl_var(inner
);
166 if (strcmp(sub_var
->name
, sub_ref
->name
)) {
167 data
->error(data
, sub_var
->token
, E_WARNING
,
168 "Inner `set` statement casts on pointers must"
169 " reference the same variable");
172 if (!psi_let_exp_validate(data
, inner
, impl
)) {
176 data
->error(data
, let_var
->token
, PSI_WARNING
,
177 "Inner let statement's values must refer to a structure or"
178 " array type, got '%s%s' for '%s'", var_typ
->name
,
179 psi_t_indirection(let_var
->arg
->var
->pointer_level
),
184 if (!psi_plist_count(func
->inner
)) {
185 data
->error(data
, func
->token
, PSI_WARNING
,
186 "No valid sub-expressions left");
194 bool psi_let_func_validate(struct psi_data
*data
, struct psi_let_exp
*val
,
195 struct psi_let_func
*func
, struct psi_impl
*impl
)
197 if (impl
->func
->args
) {
198 /* FIXME, func->var does not need to be referring to a func arg */
199 psi_impl_get_arg(impl
, func
->var
);
202 if (!psi_impl_var_validate(data
, func
->var
, impl
, val
, NULL
)) {
206 if (!validate_let_func_type(data
, func
, impl
)) {
209 if (!validate_let_func_inner(data
, val
, func
, impl
)) {
215 void exec_let_func_arrval_inner(struct psi_let_func
*func
,
216 struct psi_decl_arg
*darg
, struct psi_decl_arg
*inner_decl_arg
,
217 struct psi_call_frame_argument
*frame_arg
,
218 struct psi_let_exp
*inner_let_exp
, void *container
,
219 struct psi_call_frame
*frame
)
221 struct psi_let_func
*inner_func
= psi_let_exp_get_func(inner_let_exp
);
222 struct psi_impl_var
*inner_var
= inner_func
->var
;
224 if (psi_decl_type_get_real(darg
->type
)->type
== PSI_T_UNION
) {
225 /* skip if there's no entry in the outer_zval;
226 * we only want to set supplied data on unions
228 if (!zend_symtable_str_exists(Z_ARRVAL_P(frame_arg
->zval_ptr
),
229 &inner_var
->name
[1], strlen(&inner_var
->name
[1]))) {
233 psi_call_frame_sub_argument(frame
, inner_var
, frame_arg
->zval_ptr
,
234 inner_func
->var
->fqn
);
236 /* example from dm_store/dbm_fetch with arrval($string) conversion:
237 let key = arrval($key,
245 full_func_var_name = $key.0
246 inner_decl_arg = key.dptr
248 psi_let_exp_exec(inner_let_exp
, inner_decl_arg
,
249 ((char *) container
) + inner_decl_arg
->layout
->pos
,
250 inner_decl_arg
->layout
->len
, frame
);
253 static void *exec_let_func_arrval(struct psi_let_exp
*val
,
254 struct psi_let_func
*func
, struct psi_decl_arg
*darg
,
255 struct psi_call_frame
*frame
);
257 void exec_let_func_arrval_seq(struct psi_let_func
*func
,
258 struct psi_decl_arg
*darg
,
259 struct psi_call_frame_argument
*frame_arg
,
260 struct psi_let_exp
*inner_let_exp
, void *container
,
261 struct psi_call_frame
*frame
)
264 psi_marshal_let let_fn
;
266 struct psi_decl_var
*dvar
;
268 if (inner_let_exp
->var
) {
269 /* arrval($foo, *foo = intval($foo)); */
270 dvar
= inner_let_exp
->var
;
272 /* arrval($foo, intval($foo)); */
273 dvar
= psi_decl_var_copy(darg
->var
);
274 assert(dvar
->pointer_level
);
275 --dvar
->pointer_level
;
278 dvar
->pointer_level
+= inner_let_exp
->is_reference
;
279 size
= psi_decl_var_get_size(dvar
);
280 dvar
->pointer_level
-= inner_let_exp
->is_reference
;
282 let_fn
= locate_let_func_fn(inner_let_exp
->data
.func
->type
);
284 ZEND_HASH_FOREACH_VAL_IND(Z_ARRVAL_P(frame_arg
->zval_ptr
), zval_ptr
)
287 impl_val val
= {0}, *ptr
, *sub
;
290 ptr
= let_fn(&val
, darg
, 0, NULL
, zval_ptr
, &temp
);
292 psi_call_frame_push_auto(frame
, temp
);
294 } else if (func
->type
== PSI_T_ARRVAL
) {
295 ptr
= exec_let_func_arrval(inner_let_exp
,
296 inner_let_exp
->data
.func
, darg
, frame
);
301 sub
= deref_impl_val(ptr
, dvar
);
303 memcpy(&((char *) container
)[size
* i
++], &sub
, size
);
305 ZEND_HASH_FOREACH_END();
307 if (dvar
!= inner_let_exp
->var
) {
308 psi_decl_var_free(&dvar
);
312 static void *exec_let_func_arrval(struct psi_let_exp
*val
,
313 struct psi_let_func
*func
, struct psi_decl_arg
*darg
,
314 struct psi_call_frame
*frame
)
316 void *container
= NULL
;
317 struct psi_call_frame_argument
*frame_arg
;
318 struct psi_plist
*darg_members
;
320 darg_members
= psi_decl_type_get_args(darg
->type
, NULL
);
321 frame_arg
= psi_call_frame_get_argument(frame
, func
->var
->fqn
);
323 if (frame_arg
->zval_ptr
&& Z_TYPE_P(frame_arg
->zval_ptr
) != IS_ARRAY
) {
324 convert_to_array(frame_arg
->zval_ptr
);
327 if (darg_members
&& func
->inner
) {
330 * str = strval($str),
331 * num = intval($num));
334 struct psi_let_exp
*inner
;
335 struct psi_decl_arg
*darg_member
;
337 val
->var
->pointer_level
+= val
->is_reference
;
338 size
= psi_decl_var_get_size(val
->var
);
339 container
= ecalloc(1, size
);
340 val
->var
->pointer_level
-= val
->is_reference
;
342 if (frame_arg
->zval_ptr
) {
343 while (psi_plist_get(func
->inner
, i
++, &inner
)) {
344 darg_member
= psi_decl_arg_get_by_name(darg_members
,
345 psi_let_exp_get_decl_var_name(inner
));
347 exec_let_func_arrval_inner(func
, darg
, darg_member
, frame_arg
,
348 inner
, container
, frame
);
351 } else if (func
->inner
) {
353 * arrval($foo, foo = intval($foo))
356 struct psi_let_exp
*inner
;
358 if (!frame_arg
->zval_ptr
) {
361 assert(psi_plist_count(func
->inner
) == 1);
363 arcount
= zend_array_count(Z_ARRVAL_P(frame_arg
->zval_ptr
));
364 psi_plist_get(func
->inner
, 0, &inner
);
366 inner
->var
->pointer_level
+= inner
->is_reference
;
367 container
= ecalloc(arcount
+ 1, psi_decl_var_get_size(inner
->var
));
368 inner
->var
->pointer_level
-= inner
->is_reference
;
370 exec_let_func_arrval_seq(func
, darg
, frame_arg
, inner
, container
, frame
);
375 return *psi_call_frame_push_auto(frame
, container
);
378 void *psi_let_func_exec(struct psi_let_exp
*val
, struct psi_let_func
*func
,
379 struct psi_decl_arg
*darg
, struct psi_call_frame
*frame
)
381 struct psi_call_frame_symbol
*frame_sym
;
382 psi_marshal_let let_fn
= locate_let_func_fn(func
->type
);
384 frame_sym
= psi_call_frame_fetch_symbol(frame
, val
->var
);
388 struct psi_call_frame_argument
*iarg
;
390 iarg
= psi_call_frame_get_argument(frame
, func
->var
->fqn
);
394 frame_sym
->ival_ptr
= let_fn(&frame_sym
->temp_val
, darg
,
395 iarg
->spec
? iarg
->spec
->type
->type
: 0, iarg
->ival_ptr
,
396 iarg
->zval_ptr
, &temp
);
398 psi_call_frame_push_auto(frame
, temp
);
400 } else if (func
->type
== PSI_T_ARRVAL
) {
401 frame_sym
->ival_ptr
= exec_let_func_arrval(val
, func
, darg
, frame
);
404 return frame_sym
->ival_ptr
;