1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1998-2015 Zend Technologies Ltd. (http://www.zend.com) |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 2.00 of the Zend license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.zend.com/license/2_00.txt. |
11 | If you did not receive a copy of the Zend license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@zend.com so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Christian Seiler <chris_se@gmx.net> |
16 | Dmitry Stogov <dmitry@zend.com> |
17 | Marcus Boerger <helly@php.net> |
18 +----------------------------------------------------------------------+
19 */
20
21 /* $Id$ */
22
23 #include "zend.h"
24 #include "zend_API.h"
25 #include "zend_closures.h"
26 #include "zend_exceptions.h"
27 #include "zend_interfaces.h"
28 #include "zend_objects.h"
29 #include "zend_objects_API.h"
30 #include "zend_globals.h"
31
32 #define ZEND_CLOSURE_PRINT_NAME "Closure object"
33
34 #define ZEND_CLOSURE_PROPERTY_ERROR() \
35 zend_error(E_RECOVERABLE_ERROR, "Closure object cannot have properties")
36
37 typedef struct _zend_closure {
38 zend_object std;
39 zend_function func;
40 zval *this_ptr;
41 HashTable *debug_info;
42 } zend_closure;
43
44 /* non-static since it needs to be referenced */
45 ZEND_API zend_class_entry *zend_ce_closure;
46 static zend_object_handlers closure_handlers;
47
ZEND_METHOD(Closure,__invoke)48 ZEND_METHOD(Closure, __invoke) /* {{{ */
49 {
50 zend_function *func = EG(current_execute_data)->function_state.function;
51 zval ***arguments;
52 zval *closure_result_ptr = NULL;
53
54 arguments = emalloc(sizeof(zval**) * ZEND_NUM_ARGS());
55 if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), arguments) == FAILURE) {
56 efree(arguments);
57 zend_error(E_RECOVERABLE_ERROR, "Cannot get arguments for calling closure");
58 RETVAL_FALSE;
59 } else if (call_user_function_ex(CG(function_table), NULL, this_ptr, &closure_result_ptr, ZEND_NUM_ARGS(), arguments, 1, NULL TSRMLS_CC) == FAILURE) {
60 RETVAL_FALSE;
61 } else if (closure_result_ptr) {
62 if (Z_ISREF_P(closure_result_ptr) && return_value_ptr) {
63 if (return_value) {
64 zval_ptr_dtor(&return_value);
65 }
66 *return_value_ptr = closure_result_ptr;
67 } else {
68 RETVAL_ZVAL(closure_result_ptr, 1, 1);
69 }
70 }
71 efree(arguments);
72
73 /* destruct the function also, then - we have allocated it in get_method */
74 efree((char*)func->internal_function.function_name);
75 efree(func);
76 }
77 /* }}} */
78
79 /* {{{ proto Closure Closure::bind(Closure $old, object $to [, mixed $scope = "static" ] )
80 Create a closure from another one and bind to another object and scope */
ZEND_METHOD(Closure,bind)81 ZEND_METHOD(Closure, bind)
82 {
83 zval *newthis, *zclosure, *scope_arg = NULL;
84 zend_closure *closure;
85 zend_class_entry *ce, **ce_p;
86
87 if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo!|z", &zclosure, zend_ce_closure, &newthis, &scope_arg) == FAILURE) {
88 RETURN_NULL();
89 }
90
91 closure = (zend_closure *)zend_object_store_get_object(zclosure TSRMLS_CC);
92
93 if ((newthis != NULL) && (closure->func.common.fn_flags & ZEND_ACC_STATIC)) {
94 zend_error(E_WARNING, "Cannot bind an instance to a static closure");
95 }
96
97 if (scope_arg != NULL) { /* scope argument was given */
98 if (IS_ZEND_STD_OBJECT(*scope_arg)) {
99 ce = Z_OBJCE_P(scope_arg);
100 } else if (Z_TYPE_P(scope_arg) == IS_NULL) {
101 ce = NULL;
102 } else {
103 char *class_name;
104 int class_name_len;
105 zval tmp_zval;
106 INIT_ZVAL(tmp_zval);
107
108 if (Z_TYPE_P(scope_arg) == IS_STRING) {
109 class_name = Z_STRVAL_P(scope_arg);
110 class_name_len = Z_STRLEN_P(scope_arg);
111 } else {
112 tmp_zval = *scope_arg;
113 zval_copy_ctor(&tmp_zval);
114 convert_to_string(&tmp_zval);
115 class_name = Z_STRVAL(tmp_zval);
116 class_name_len = Z_STRLEN(tmp_zval);
117 }
118
119 if ((class_name_len == sizeof("static") - 1) &&
120 (memcmp("static", class_name, sizeof("static") - 1) == 0)) {
121 ce = closure->func.common.scope;
122 }
123 else if (zend_lookup_class_ex(class_name, class_name_len, NULL, 1, &ce_p TSRMLS_CC) == FAILURE) {
124 zend_error(E_WARNING, "Class '%s' not found", class_name);
125 zval_dtor(&tmp_zval);
126 RETURN_NULL();
127 } else {
128 ce = *ce_p;
129 }
130 zval_dtor(&tmp_zval);
131 }
132 } else { /* scope argument not given; do not change the scope by default */
133 ce = closure->func.common.scope;
134 }
135
136 zend_create_closure(return_value, &closure->func, ce, newthis TSRMLS_CC);
137 }
138 /* }}} */
139
zend_closure_get_constructor(zval * object TSRMLS_DC)140 static zend_function *zend_closure_get_constructor(zval *object TSRMLS_DC) /* {{{ */
141 {
142 zend_error(E_RECOVERABLE_ERROR, "Instantiation of 'Closure' is not allowed");
143 return NULL;
144 }
145 /* }}} */
146
zend_closure_compare_objects(zval * o1,zval * o2 TSRMLS_DC)147 static int zend_closure_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
148 {
149 return (Z_OBJ_HANDLE_P(o1) != Z_OBJ_HANDLE_P(o2));
150 }
151 /* }}} */
152
zend_get_closure_invoke_method(zval * obj TSRMLS_DC)153 ZEND_API zend_function *zend_get_closure_invoke_method(zval *obj TSRMLS_DC) /* {{{ */
154 {
155 zend_closure *closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
156 zend_function *invoke = (zend_function*)emalloc(sizeof(zend_function));
157
158 invoke->common = closure->func.common;
159 invoke->type = ZEND_INTERNAL_FUNCTION;
160 invoke->internal_function.fn_flags = ZEND_ACC_PUBLIC | ZEND_ACC_CALL_VIA_HANDLER | (closure->func.common.fn_flags & ZEND_ACC_RETURN_REFERENCE);
161 invoke->internal_function.handler = ZEND_MN(Closure___invoke);
162 invoke->internal_function.module = 0;
163 invoke->internal_function.scope = zend_ce_closure;
164 invoke->internal_function.function_name = estrndup(ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1);
165 return invoke;
166 }
167 /* }}} */
168
zend_get_closure_method_def(zval * obj TSRMLS_DC)169 ZEND_API const zend_function *zend_get_closure_method_def(zval *obj TSRMLS_DC) /* {{{ */
170 {
171 zend_closure *closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
172 return &closure->func;
173 }
174 /* }}} */
175
zend_get_closure_this_ptr(zval * obj TSRMLS_DC)176 ZEND_API zval* zend_get_closure_this_ptr(zval *obj TSRMLS_DC) /* {{{ */
177 {
178 zend_closure *closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
179 return closure->this_ptr;
180 }
181 /* }}} */
182
zend_closure_get_method(zval ** object_ptr,char * method_name,int method_len,const zend_literal * key TSRMLS_DC)183 static zend_function *zend_closure_get_method(zval **object_ptr, char *method_name, int method_len, const zend_literal *key TSRMLS_DC) /* {{{ */
184 {
185 char *lc_name;
186 ALLOCA_FLAG(use_heap)
187
188 lc_name = do_alloca(method_len + 1, use_heap);
189 zend_str_tolower_copy(lc_name, method_name, method_len);
190 if ((method_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) &&
191 memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
192 ) {
193 free_alloca(lc_name, use_heap);
194 return zend_get_closure_invoke_method(*object_ptr TSRMLS_CC);
195 }
196 free_alloca(lc_name, use_heap);
197 return std_object_handlers.get_method(object_ptr, method_name, method_len, key TSRMLS_CC);
198 }
199 /* }}} */
200
zend_closure_read_property(zval * object,zval * member,int type,const zend_literal * key TSRMLS_DC)201 static zval *zend_closure_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
202 {
203 ZEND_CLOSURE_PROPERTY_ERROR();
204 Z_ADDREF(EG(uninitialized_zval));
205 return &EG(uninitialized_zval);
206 }
207 /* }}} */
208
zend_closure_write_property(zval * object,zval * member,zval * value,const zend_literal * key TSRMLS_DC)209 static void zend_closure_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
210 {
211 ZEND_CLOSURE_PROPERTY_ERROR();
212 }
213 /* }}} */
214
zend_closure_get_property_ptr_ptr(zval * object,zval * member,int type,const zend_literal * key TSRMLS_DC)215 static zval **zend_closure_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
216 {
217 ZEND_CLOSURE_PROPERTY_ERROR();
218 return NULL;
219 }
220 /* }}} */
221
zend_closure_has_property(zval * object,zval * member,int has_set_exists,const zend_literal * key TSRMLS_DC)222 static int zend_closure_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
223 {
224 if (has_set_exists != 2) {
225 ZEND_CLOSURE_PROPERTY_ERROR();
226 }
227 return 0;
228 }
229 /* }}} */
230
zend_closure_unset_property(zval * object,zval * member,const zend_literal * key TSRMLS_DC)231 static void zend_closure_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
232 {
233 ZEND_CLOSURE_PROPERTY_ERROR();
234 }
235 /* }}} */
236
zend_closure_free_storage(void * object TSRMLS_DC)237 static void zend_closure_free_storage(void *object TSRMLS_DC) /* {{{ */
238 {
239 zend_closure *closure = (zend_closure *)object;
240
241 zend_object_std_dtor(&closure->std TSRMLS_CC);
242
243 if (closure->func.type == ZEND_USER_FUNCTION) {
244 zend_execute_data *ex = EG(current_execute_data);
245 while (ex) {
246 if (ex->op_array == &closure->func.op_array) {
247 zend_error(E_ERROR, "Cannot destroy active lambda function");
248 }
249 ex = ex->prev_execute_data;
250 }
251 destroy_op_array(&closure->func.op_array TSRMLS_CC);
252 }
253
254 if (closure->debug_info != NULL) {
255 zend_hash_destroy(closure->debug_info);
256 efree(closure->debug_info);
257 }
258
259 if (closure->this_ptr) {
260 zval_ptr_dtor(&closure->this_ptr);
261 }
262
263 efree(closure);
264 }
265 /* }}} */
266
zend_closure_new(zend_class_entry * class_type TSRMLS_DC)267 static zend_object_value zend_closure_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
268 {
269 zend_closure *closure;
270 zend_object_value object;
271
272 closure = emalloc(sizeof(zend_closure));
273 memset(closure, 0, sizeof(zend_closure));
274
275 zend_object_std_init(&closure->std, class_type TSRMLS_CC);
276
277 object.handle = zend_objects_store_put(closure, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) zend_closure_free_storage, NULL TSRMLS_CC);
278 object.handlers = &closure_handlers;
279
280 return object;
281 }
282 /* }}} */
283
zend_closure_clone(zval * zobject TSRMLS_DC)284 static zend_object_value zend_closure_clone(zval *zobject TSRMLS_DC) /* {{{ */
285 {
286 zend_closure *closure = (zend_closure *)zend_object_store_get_object(zobject TSRMLS_CC);
287 zval result;
288
289 zend_create_closure(&result, &closure->func, closure->func.common.scope, closure->this_ptr TSRMLS_CC);
290 return Z_OBJVAL(result);
291 }
292 /* }}} */
293
zend_closure_get_closure(zval * obj,zend_class_entry ** ce_ptr,zend_function ** fptr_ptr,zval ** zobj_ptr TSRMLS_DC)294 int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zval **zobj_ptr TSRMLS_DC) /* {{{ */
295 {
296 zend_closure *closure;
297
298 if (Z_TYPE_P(obj) != IS_OBJECT) {
299 return FAILURE;
300 }
301
302 closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
303 *fptr_ptr = &closure->func;
304
305 if (closure->this_ptr) {
306 if (zobj_ptr) {
307 *zobj_ptr = closure->this_ptr;
308 }
309 *ce_ptr = Z_OBJCE_P(closure->this_ptr);
310 } else {
311 if (zobj_ptr) {
312 *zobj_ptr = NULL;
313 }
314 *ce_ptr = closure->func.common.scope;
315 }
316 return SUCCESS;
317 }
318 /* }}} */
319
zend_closure_get_debug_info(zval * object,int * is_temp TSRMLS_DC)320 static HashTable *zend_closure_get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
321 {
322 zend_closure *closure = (zend_closure *)zend_object_store_get_object(object TSRMLS_CC);
323 zval *val;
324 struct _zend_arg_info *arg_info = closure->func.common.arg_info;
325
326 *is_temp = 0;
327
328 if (closure->debug_info == NULL) {
329 ALLOC_HASHTABLE(closure->debug_info);
330 zend_hash_init(closure->debug_info, 1, NULL, ZVAL_PTR_DTOR, 0);
331 }
332 if (closure->debug_info->nApplyCount == 0) {
333 if (closure->func.type == ZEND_USER_FUNCTION && closure->func.op_array.static_variables) {
334 HashTable *static_variables = closure->func.op_array.static_variables;
335 MAKE_STD_ZVAL(val);
336 array_init(val);
337 zend_hash_copy(Z_ARRVAL_P(val), static_variables, (copy_ctor_func_t)zval_add_ref, NULL, sizeof(zval*));
338 zend_hash_update(closure->debug_info, "static", sizeof("static"), (void *) &val, sizeof(zval *), NULL);
339 }
340
341 if (closure->this_ptr) {
342 Z_ADDREF_P(closure->this_ptr);
343 zend_symtable_update(closure->debug_info, "this", sizeof("this"), (void *) &closure->this_ptr, sizeof(zval *), NULL);
344 }
345
346 if (arg_info) {
347 zend_uint i, required = closure->func.common.required_num_args;
348
349 MAKE_STD_ZVAL(val);
350 array_init(val);
351
352 for (i = 0; i < closure->func.common.num_args; i++) {
353 char *name, *info;
354 int name_len, info_len;
355 if (arg_info->name) {
356 name_len = zend_spprintf(&name, 0, "%s$%s",
357 arg_info->pass_by_reference ? "&" : "",
358 arg_info->name);
359 } else {
360 name_len = zend_spprintf(&name, 0, "%s$param%d",
361 arg_info->pass_by_reference ? "&" : "",
362 i + 1);
363 }
364 info_len = zend_spprintf(&info, 0, "%s",
365 i >= required ? "<optional>" : "<required>");
366 add_assoc_stringl_ex(val, name, name_len + 1, info, info_len, 0);
367 efree(name);
368 arg_info++;
369 }
370 zend_hash_update(closure->debug_info, "parameter", sizeof("parameter"), (void *) &val, sizeof(zval *), NULL);
371 }
372 }
373
374 return closure->debug_info;
375 }
376 /* }}} */
377
zend_closure_get_gc(zval * obj,zval *** table,int * n TSRMLS_DC)378 static HashTable *zend_closure_get_gc(zval *obj, zval ***table, int *n TSRMLS_DC) /* {{{ */
379 {
380 zend_closure *closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
381
382 *table = closure->this_ptr ? &closure->this_ptr : NULL;
383 *n = closure->this_ptr ? 1 : 0;
384 return (closure->func.type == ZEND_USER_FUNCTION) ?
385 closure->func.op_array.static_variables : NULL;
386 }
387 /* }}} */
388
389 /* {{{ proto Closure::__construct()
390 Private constructor preventing instantiation */
ZEND_METHOD(Closure,__construct)391 ZEND_METHOD(Closure, __construct)
392 {
393 zend_error(E_RECOVERABLE_ERROR, "Instantiation of 'Closure' is not allowed");
394 }
395 /* }}} */
396
397 ZEND_BEGIN_ARG_INFO_EX(arginfo_closure_bindto, 0, 0, 1)
398 ZEND_ARG_INFO(0, newthis)
399 ZEND_ARG_INFO(0, newscope)
400 ZEND_END_ARG_INFO()
401
402 ZEND_BEGIN_ARG_INFO_EX(arginfo_closure_bind, 0, 0, 2)
403 ZEND_ARG_INFO(0, closure)
404 ZEND_ARG_INFO(0, newthis)
405 ZEND_ARG_INFO(0, newscope)
406 ZEND_END_ARG_INFO()
407
408 static const zend_function_entry closure_functions[] = {
409 ZEND_ME(Closure, __construct, NULL, ZEND_ACC_PRIVATE)
410 ZEND_ME(Closure, bind, arginfo_closure_bind, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
411 ZEND_MALIAS(Closure, bindTo, bind, arginfo_closure_bindto, ZEND_ACC_PUBLIC)
412 {NULL, NULL, NULL}
413 };
414
zend_register_closure_ce(TSRMLS_D)415 void zend_register_closure_ce(TSRMLS_D) /* {{{ */
416 {
417 zend_class_entry ce;
418
419 INIT_CLASS_ENTRY(ce, "Closure", closure_functions);
420 zend_ce_closure = zend_register_internal_class(&ce TSRMLS_CC);
421 zend_ce_closure->ce_flags |= ZEND_ACC_FINAL_CLASS;
422 zend_ce_closure->create_object = zend_closure_new;
423 zend_ce_closure->serialize = zend_class_serialize_deny;
424 zend_ce_closure->unserialize = zend_class_unserialize_deny;
425
426 memcpy(&closure_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
427 closure_handlers.get_constructor = zend_closure_get_constructor;
428 closure_handlers.get_method = zend_closure_get_method;
429 closure_handlers.write_property = zend_closure_write_property;
430 closure_handlers.read_property = zend_closure_read_property;
431 closure_handlers.get_property_ptr_ptr = zend_closure_get_property_ptr_ptr;
432 closure_handlers.has_property = zend_closure_has_property;
433 closure_handlers.unset_property = zend_closure_unset_property;
434 closure_handlers.compare_objects = zend_closure_compare_objects;
435 closure_handlers.clone_obj = zend_closure_clone;
436 closure_handlers.get_debug_info = zend_closure_get_debug_info;
437 closure_handlers.get_closure = zend_closure_get_closure;
438 closure_handlers.get_gc = zend_closure_get_gc;
439 }
440 /* }}} */
441
zend_create_closure(zval * res,zend_function * func,zend_class_entry * scope,zval * this_ptr TSRMLS_DC)442 ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_entry *scope, zval *this_ptr TSRMLS_DC) /* {{{ */
443 {
444 zend_closure *closure;
445
446 object_init_ex(res, zend_ce_closure);
447
448 closure = (zend_closure *)zend_object_store_get_object(res TSRMLS_CC);
449
450 closure->func = *func;
451 closure->func.common.prototype = NULL;
452 closure->func.common.fn_flags |= ZEND_ACC_CLOSURE;
453
454 if ((scope == NULL) && (this_ptr != NULL)) {
455 /* use dummy scope if we're binding an object without specifying a scope */
456 /* maybe it would be better to create one for this purpose */
457 scope = zend_ce_closure;
458 }
459
460 if (closure->func.type == ZEND_USER_FUNCTION) {
461 if (closure->func.op_array.static_variables) {
462 HashTable *static_variables = closure->func.op_array.static_variables;
463
464 ALLOC_HASHTABLE(closure->func.op_array.static_variables);
465 zend_hash_init(closure->func.op_array.static_variables, zend_hash_num_elements(static_variables), NULL, ZVAL_PTR_DTOR, 0);
466 zend_hash_apply_with_arguments(static_variables TSRMLS_CC, (apply_func_args_t)zval_copy_static_var, 1, closure->func.op_array.static_variables);
467 }
468 closure->func.op_array.run_time_cache = NULL;
469 (*closure->func.op_array.refcount)++;
470 } else {
471 /* verify that we aren't binding internal function to a wrong scope */
472 if(func->common.scope != NULL) {
473 if(scope && !instanceof_function(scope, func->common.scope TSRMLS_CC)) {
474 zend_error(E_WARNING, "Cannot bind function %s::%s to scope class %s", func->common.scope->name, func->common.function_name, scope->name);
475 scope = NULL;
476 }
477 if(scope && this_ptr && (func->common.fn_flags & ZEND_ACC_STATIC) == 0 &&
478 !instanceof_function(Z_OBJCE_P(this_ptr), closure->func.common.scope TSRMLS_CC)) {
479 zend_error(E_WARNING, "Cannot bind function %s::%s to object of class %s", func->common.scope->name, func->common.function_name, Z_OBJCE_P(this_ptr)->name);
480 scope = NULL;
481 this_ptr = NULL;
482 }
483 } else {
484 /* if it's a free function, we won't set scope & this since they're meaningless */
485 this_ptr = NULL;
486 scope = NULL;
487 }
488 }
489
490 closure->this_ptr = NULL;
491 /* Invariants:
492 * If the closure is unscoped, it has no bound object.
493 * The the closure is scoped, it's either static or it's bound */
494 closure->func.common.scope = scope;
495 if (scope) {
496 closure->func.common.fn_flags |= ZEND_ACC_PUBLIC;
497 if (this_ptr && (closure->func.common.fn_flags & ZEND_ACC_STATIC) == 0) {
498 closure->this_ptr = this_ptr;
499 Z_ADDREF_P(this_ptr);
500 } else {
501 closure->func.common.fn_flags |= ZEND_ACC_STATIC;
502 }
503 }
504 }
505 /* }}} */
506
507 /*
508 * Local variables:
509 * tab-width: 4
510 * c-basic-offset: 4
511 * indent-tabs-mode: t
512 * End:
513 */
514