1/*
2   +----------------------------------------------------------------------+
3   | Zend Engine                                                          |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 1998-2018 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@php.net>                              |
17   |          Marcus Boerger <helly@php.net>                              |
18   +----------------------------------------------------------------------+
19*/
20
21#include "zend.h"
22#include "zend_API.h"
23#include "zend_closures.h"
24#include "zend_exceptions.h"
25#include "zend_interfaces.h"
26#include "zend_objects.h"
27#include "zend_objects_API.h"
28#include "zend_globals.h"
29
30#define ZEND_CLOSURE_PRINT_NAME "Closure object"
31
32#define ZEND_CLOSURE_PROPERTY_ERROR() \
33	zend_throw_error(NULL, "Closure object cannot have properties")
34
35typedef struct _zend_closure {
36	zend_object       std;
37	zend_function     func;
38	zval              this_ptr;
39	zend_class_entry *called_scope;
40	zif_handler       orig_internal_handler;
41} zend_closure;
42
43/* non-static since it needs to be referenced */
44ZEND_API zend_class_entry *zend_ce_closure;
45static zend_object_handlers closure_handlers;
46
47ZEND_METHOD(Closure, __invoke) /* {{{ */
48{
49	zend_function *func = EX(func);
50	zval *arguments = ZEND_CALL_ARG(execute_data, 1);
51
52	if (call_user_function(CG(function_table), NULL, getThis(), return_value, ZEND_NUM_ARGS(), arguments) == FAILURE) {
53		RETVAL_FALSE;
54	}
55
56	/* destruct the function also, then - we have allocated it in get_method */
57	zend_string_release_ex(func->internal_function.function_name, 0);
58	efree(func);
59#if ZEND_DEBUG
60	execute_data->func = NULL;
61#endif
62}
63/* }}} */
64
65static zend_bool zend_valid_closure_binding(
66		zend_closure *closure, zval *newthis, zend_class_entry *scope) /* {{{ */
67{
68	zend_function *func = &closure->func;
69	zend_bool is_fake_closure = (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) != 0;
70	if (newthis) {
71		if (func->common.fn_flags & ZEND_ACC_STATIC) {
72			zend_error(E_WARNING, "Cannot bind an instance to a static closure");
73			return 0;
74		}
75
76		if (is_fake_closure && func->common.scope &&
77				!instanceof_function(Z_OBJCE_P(newthis), func->common.scope)) {
78			/* Binding incompatible $this to an internal method is not supported. */
79			zend_error(E_WARNING, "Cannot bind method %s::%s() to object of class %s",
80					ZSTR_VAL(func->common.scope->name),
81					ZSTR_VAL(func->common.function_name),
82					ZSTR_VAL(Z_OBJCE_P(newthis)->name));
83			return 0;
84		}
85	} else if (!(func->common.fn_flags & ZEND_ACC_STATIC) && func->common.scope
86			&& func->type == ZEND_INTERNAL_FUNCTION) {
87		zend_error(E_WARNING, "Cannot unbind $this of internal method");
88		return 0;
89	}
90
91	if (scope && scope != func->common.scope && scope->type == ZEND_INTERNAL_CLASS) {
92		/* rebinding to internal class is not allowed */
93		zend_error(E_WARNING, "Cannot bind closure to scope of internal class %s",
94				ZSTR_VAL(scope->name));
95		return 0;
96	}
97
98	if (is_fake_closure && scope != func->common.scope) {
99		zend_error(E_WARNING, "Cannot rebind scope of closure created by ReflectionFunctionAbstract::getClosure()");
100		return 0;
101	}
102
103	return 1;
104}
105/* }}} */
106
107/* {{{ proto mixed Closure::call(object to [, mixed parameter] [, mixed ...] )
108   Call closure, binding to a given object with its class as the scope */
109ZEND_METHOD(Closure, call)
110{
111	zval *zclosure, *newthis, closure_result;
112	zend_closure *closure;
113	zend_fcall_info fci;
114	zend_fcall_info_cache fci_cache;
115	zend_function my_function;
116	zend_object *newobj;
117
118	fci.param_count = 0;
119	fci.params = NULL;
120
121	if (zend_parse_parameters(ZEND_NUM_ARGS(), "o*", &newthis, &fci.params, &fci.param_count) == FAILURE) {
122		return;
123	}
124
125	zclosure = getThis();
126	closure = (zend_closure *) Z_OBJ_P(zclosure);
127
128	newobj = Z_OBJ_P(newthis);
129
130	if (!zend_valid_closure_binding(closure, newthis, Z_OBJCE_P(newthis))) {
131		return;
132	}
133
134	if (closure->func.common.fn_flags & ZEND_ACC_GENERATOR) {
135		zval new_closure;
136		zend_create_closure(&new_closure, &closure->func, Z_OBJCE_P(newthis), closure->called_scope, newthis);
137		closure = (zend_closure *) Z_OBJ(new_closure);
138		fci_cache.function_handler = &closure->func;
139	} else {
140		memcpy(&my_function, &closure->func, closure->func.type == ZEND_USER_FUNCTION ? sizeof(zend_op_array) : sizeof(zend_internal_function));
141		my_function.common.fn_flags &= ~ZEND_ACC_CLOSURE;
142		/* use scope of passed object */
143		my_function.common.scope = Z_OBJCE_P(newthis);
144		fci_cache.function_handler = &my_function;
145
146		/* Runtime cache relies on bound scope to be immutable, hence we need a separate rt cache in case scope changed */
147		if (ZEND_USER_CODE(my_function.type) && closure->func.common.scope != Z_OBJCE_P(newthis)) {
148			my_function.op_array.run_time_cache = emalloc(my_function.op_array.cache_size);
149			memset(my_function.op_array.run_time_cache, 0, my_function.op_array.cache_size);
150		}
151	}
152
153	fci_cache.called_scope = newobj->ce;
154	fci_cache.object = fci.object = newobj;
155
156	fci.size = sizeof(fci);
157	ZVAL_COPY_VALUE(&fci.function_name, zclosure);
158	fci.retval = &closure_result;
159	fci.no_separation = 1;
160
161	if (zend_call_function(&fci, &fci_cache) == SUCCESS && Z_TYPE(closure_result) != IS_UNDEF) {
162		if (Z_ISREF(closure_result)) {
163			zend_unwrap_reference(&closure_result);
164		}
165		ZVAL_COPY_VALUE(return_value, &closure_result);
166	}
167
168	if (fci_cache.function_handler->common.fn_flags & ZEND_ACC_GENERATOR) {
169		/* copied upon generator creation */
170		GC_DELREF(&closure->std);
171	} else if (ZEND_USER_CODE(my_function.type) && closure->func.common.scope != Z_OBJCE_P(newthis)) {
172		efree(my_function.op_array.run_time_cache);
173	}
174}
175/* }}} */
176
177/* {{{ proto Closure Closure::bind(callable old, object to [, mixed scope])
178   Create a closure from another one and bind to another object and scope */
179ZEND_METHOD(Closure, bind)
180{
181	zval *newthis, *zclosure, *scope_arg = NULL;
182	zend_closure *closure;
183	zend_class_entry *ce, *called_scope;
184
185	if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "Oo!|z", &zclosure, zend_ce_closure, &newthis, &scope_arg) == FAILURE) {
186		return;
187	}
188
189	closure = (zend_closure *)Z_OBJ_P(zclosure);
190
191	if (scope_arg != NULL) { /* scope argument was given */
192		if (Z_TYPE_P(scope_arg) == IS_OBJECT) {
193			ce = Z_OBJCE_P(scope_arg);
194		} else if (Z_TYPE_P(scope_arg) == IS_NULL) {
195			ce = NULL;
196		} else {
197			zend_string *tmp_class_name;
198			zend_string *class_name = zval_get_tmp_string(scope_arg, &tmp_class_name);
199			if (zend_string_equals_literal(class_name, "static")) {
200				ce = closure->func.common.scope;
201			} else if ((ce = zend_lookup_class_ex(class_name, NULL, 1)) == NULL) {
202				zend_error(E_WARNING, "Class '%s' not found", ZSTR_VAL(class_name));
203				zend_tmp_string_release(tmp_class_name);
204				RETURN_NULL();
205			}
206			zend_tmp_string_release(tmp_class_name);
207		}
208	} else { /* scope argument not given; do not change the scope by default */
209		ce = closure->func.common.scope;
210	}
211
212	if (!zend_valid_closure_binding(closure, newthis, ce)) {
213		return;
214	}
215
216	if (newthis) {
217		called_scope = Z_OBJCE_P(newthis);
218	} else {
219		called_scope = ce;
220	}
221
222	zend_create_closure(return_value, &closure->func, ce, called_scope, newthis);
223}
224/* }}} */
225
226static ZEND_NAMED_FUNCTION(zend_closure_call_magic) /* {{{ */ {
227	zend_fcall_info fci;
228	zend_fcall_info_cache fcc;
229	zval params[2];
230
231	memset(&fci, 0, sizeof(zend_fcall_info));
232	memset(&fcc, 0, sizeof(zend_fcall_info_cache));
233
234	fci.size = sizeof(zend_fcall_info);
235	fci.retval = return_value;
236
237	fcc.function_handler = (EX(func)->internal_function.fn_flags & ZEND_ACC_STATIC) ?
238		EX(func)->internal_function.scope->__callstatic : EX(func)->internal_function.scope->__call;
239	fci.params = params;
240	fci.param_count = 2;
241	ZVAL_STR(&fci.params[0], EX(func)->common.function_name);
242	if (ZEND_NUM_ARGS()) {
243		array_init_size(&fci.params[1], ZEND_NUM_ARGS());
244		zend_copy_parameters_array(ZEND_NUM_ARGS(), &fci.params[1]);
245	} else {
246		ZVAL_EMPTY_ARRAY(&fci.params[1]);
247	}
248
249	fci.object = Z_OBJ(EX(This));
250	fcc.object = Z_OBJ(EX(This));
251
252	zend_call_function(&fci, &fcc);
253
254	zval_ptr_dtor(&fci.params[0]);
255	zval_ptr_dtor(&fci.params[1]);
256}
257/* }}} */
258
259static int zend_create_closure_from_callable(zval *return_value, zval *callable, char **error) /* {{{ */ {
260	zend_fcall_info_cache fcc;
261	zend_function *mptr;
262	zval instance;
263	zend_internal_function call;
264
265	if (!zend_is_callable_ex(callable, NULL, 0, NULL, &fcc, error)) {
266		return FAILURE;
267	}
268
269	mptr = fcc.function_handler;
270	if (mptr->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
271		/* For Closure::fromCallable([$closure, "__invoke"]) return $closure. */
272		if (fcc.object && fcc.object->ce == zend_ce_closure
273				&& zend_string_equals_literal(mptr->common.function_name, "__invoke")) {
274			ZVAL_OBJ(return_value, fcc.object);
275			GC_ADDREF(fcc.object);
276			zend_free_trampoline(mptr);
277			return SUCCESS;
278		}
279
280		memset(&call, 0, sizeof(zend_internal_function));
281		call.type = ZEND_INTERNAL_FUNCTION;
282		call.fn_flags = mptr->common.fn_flags & ZEND_ACC_STATIC;
283		call.handler = zend_closure_call_magic;
284		call.function_name = mptr->common.function_name;
285		call.scope = mptr->common.scope;
286
287		zend_free_trampoline(mptr);
288		mptr = (zend_function *) &call;
289	}
290
291	if (fcc.object) {
292		ZVAL_OBJ(&instance, fcc.object);
293		zend_create_fake_closure(return_value, mptr, mptr->common.scope, fcc.called_scope, &instance);
294	} else {
295		zend_create_fake_closure(return_value, mptr, mptr->common.scope, fcc.called_scope, NULL);
296	}
297
298	return SUCCESS;
299}
300/* }}} */
301
302/* {{{ proto Closure Closure::fromCallable(callable callable)
303   Create a closure from a callable using the current scope. */
304ZEND_METHOD(Closure, fromCallable)
305{
306	zval *callable;
307	int success;
308	char *error = NULL;
309
310	if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &callable) == FAILURE) {
311		return;
312	}
313
314	if (Z_TYPE_P(callable) == IS_OBJECT && instanceof_function(Z_OBJCE_P(callable), zend_ce_closure)) {
315		/* It's already a closure */
316		RETURN_ZVAL(callable, 1, 0);
317	}
318
319	/* create closure as if it were called from parent scope */
320	EG(current_execute_data) = EX(prev_execute_data);
321	success = zend_create_closure_from_callable(return_value, callable, &error);
322	EG(current_execute_data) = execute_data;
323
324	if (success == FAILURE || error) {
325		if (error) {
326			zend_throw_exception_ex(zend_ce_type_error, 0, "Failed to create closure from callable: %s", error);
327			efree(error);
328		} else {
329			zend_throw_exception_ex(zend_ce_type_error, 0, "Failed to create closure from callable");
330		}
331	}
332}
333/* }}} */
334
335static ZEND_COLD zend_function *zend_closure_get_constructor(zend_object *object) /* {{{ */
336{
337	zend_throw_error(NULL, "Instantiation of 'Closure' is not allowed");
338	return NULL;
339}
340/* }}} */
341
342static int zend_closure_compare_objects(zval *o1, zval *o2) /* {{{ */
343{
344	return (Z_OBJ_P(o1) != Z_OBJ_P(o2));
345}
346/* }}} */
347
348ZEND_API zend_function *zend_get_closure_invoke_method(zend_object *object) /* {{{ */
349{
350	zend_closure *closure = (zend_closure *)object;
351	zend_function *invoke = (zend_function*)emalloc(sizeof(zend_function));
352	const uint32_t keep_flags =
353		ZEND_ACC_RETURN_REFERENCE | ZEND_ACC_VARIADIC | ZEND_ACC_HAS_RETURN_TYPE;
354
355	invoke->common = closure->func.common;
356	/* We return ZEND_INTERNAL_FUNCTION, but arg_info representation is the
357	 * same as for ZEND_USER_FUNCTION (uses zend_string* instead of char*).
358	 * This is not a problem, because ZEND_ACC_HAS_TYPE_HINTS is never set,
359	 * and we won't check arguments on internal function. We also set
360	 * ZEND_ACC_USER_ARG_INFO flag to prevent invalid usage by Reflection */
361	invoke->type = ZEND_INTERNAL_FUNCTION;
362	invoke->internal_function.fn_flags =
363		ZEND_ACC_PUBLIC | ZEND_ACC_CALL_VIA_HANDLER | (closure->func.common.fn_flags & keep_flags);
364	if (closure->func.type != ZEND_INTERNAL_FUNCTION || (closure->func.common.fn_flags & ZEND_ACC_USER_ARG_INFO)) {
365		invoke->internal_function.fn_flags |=
366			ZEND_ACC_USER_ARG_INFO;
367	}
368	invoke->internal_function.handler = ZEND_MN(Closure___invoke);
369	invoke->internal_function.module = 0;
370	invoke->internal_function.scope = zend_ce_closure;
371	invoke->internal_function.function_name = ZSTR_KNOWN(ZEND_STR_MAGIC_INVOKE);
372	return invoke;
373}
374/* }}} */
375
376ZEND_API const zend_function *zend_get_closure_method_def(zval *obj) /* {{{ */
377{
378	zend_closure *closure = (zend_closure *)Z_OBJ_P(obj);
379	return &closure->func;
380}
381/* }}} */
382
383ZEND_API zval* zend_get_closure_this_ptr(zval *obj) /* {{{ */
384{
385	zend_closure *closure = (zend_closure *)Z_OBJ_P(obj);
386	return &closure->this_ptr;
387}
388/* }}} */
389
390static zend_function *zend_closure_get_method(zend_object **object, zend_string *method, const zval *key) /* {{{ */
391{
392	if (zend_string_equals_literal_ci(method, ZEND_INVOKE_FUNC_NAME)) {
393		return zend_get_closure_invoke_method(*object);
394	}
395
396	return zend_std_get_method(object, method, key);
397}
398/* }}} */
399
400static zval *zend_closure_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv) /* {{{ */
401{
402	ZEND_CLOSURE_PROPERTY_ERROR();
403	return &EG(uninitialized_zval);
404}
405/* }}} */
406
407static void zend_closure_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
408{
409	ZEND_CLOSURE_PROPERTY_ERROR();
410}
411/* }}} */
412
413static zval *zend_closure_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot) /* {{{ */
414{
415	ZEND_CLOSURE_PROPERTY_ERROR();
416	return NULL;
417}
418/* }}} */
419
420static int zend_closure_has_property(zval *object, zval *member, int has_set_exists, void **cache_slot) /* {{{ */
421{
422	if (has_set_exists != ZEND_PROPERTY_EXISTS) {
423		ZEND_CLOSURE_PROPERTY_ERROR();
424	}
425	return 0;
426}
427/* }}} */
428
429static void zend_closure_unset_property(zval *object, zval *member, void **cache_slot) /* {{{ */
430{
431	ZEND_CLOSURE_PROPERTY_ERROR();
432}
433/* }}} */
434
435static void zend_closure_free_storage(zend_object *object) /* {{{ */
436{
437	zend_closure *closure = (zend_closure *)object;
438
439	zend_object_std_dtor(&closure->std);
440
441	if (closure->func.type == ZEND_USER_FUNCTION) {
442		if (closure->func.op_array.fn_flags & ZEND_ACC_NO_RT_ARENA) {
443			efree(closure->func.op_array.run_time_cache);
444			closure->func.op_array.run_time_cache = NULL;
445		}
446		destroy_op_array(&closure->func.op_array);
447	}
448
449	if (Z_TYPE(closure->this_ptr) != IS_UNDEF) {
450		zval_ptr_dtor(&closure->this_ptr);
451	}
452}
453/* }}} */
454
455static zend_object *zend_closure_new(zend_class_entry *class_type) /* {{{ */
456{
457	zend_closure *closure;
458
459	closure = emalloc(sizeof(zend_closure));
460	memset(closure, 0, sizeof(zend_closure));
461
462	zend_object_std_init(&closure->std, class_type);
463	closure->std.handlers = &closure_handlers;
464
465	return (zend_object*)closure;
466}
467/* }}} */
468
469static zend_object *zend_closure_clone(zval *zobject) /* {{{ */
470{
471	zend_closure *closure = (zend_closure *)Z_OBJ_P(zobject);
472	zval result;
473
474	zend_create_closure(&result, &closure->func,
475		closure->func.common.scope, closure->called_scope, &closure->this_ptr);
476	return Z_OBJ(result);
477}
478/* }}} */
479
480int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zend_object **obj_ptr) /* {{{ */
481{
482	zend_closure *closure = (zend_closure *)Z_OBJ_P(obj);
483	*fptr_ptr = &closure->func;
484	*ce_ptr = closure->called_scope;
485
486	if (Z_TYPE(closure->this_ptr) != IS_UNDEF) {
487		*obj_ptr = Z_OBJ(closure->this_ptr);
488	} else {
489		*obj_ptr = NULL;
490	}
491
492	return SUCCESS;
493}
494/* }}} */
495
496static HashTable *zend_closure_get_debug_info(zval *object, int *is_temp) /* {{{ */
497{
498	zend_closure *closure = (zend_closure *)Z_OBJ_P(object);
499	zval val;
500	struct _zend_arg_info *arg_info = closure->func.common.arg_info;
501	HashTable *debug_info;
502	zend_bool zstr_args = (closure->func.type == ZEND_USER_FUNCTION) || (closure->func.common.fn_flags & ZEND_ACC_USER_ARG_INFO);
503
504	*is_temp = 1;
505
506	debug_info = zend_new_array(8);
507
508	if (closure->func.type == ZEND_USER_FUNCTION && closure->func.op_array.static_variables) {
509		zval *var;
510		HashTable *static_variables = closure->func.op_array.static_variables;
511		ZVAL_ARR(&val, zend_array_dup(static_variables));
512		zend_hash_update(debug_info, ZSTR_KNOWN(ZEND_STR_STATIC), &val);
513		ZEND_HASH_FOREACH_VAL(Z_ARRVAL(val), var) {
514			if (Z_TYPE_P(var) == IS_CONSTANT_AST) {
515				zval_ptr_dtor(var);
516				ZVAL_STRING(var, "<constant ast>");
517			}
518		} ZEND_HASH_FOREACH_END();
519	}
520
521	if (Z_TYPE(closure->this_ptr) != IS_UNDEF) {
522		Z_ADDREF(closure->this_ptr);
523		zend_hash_update(debug_info, ZSTR_KNOWN(ZEND_STR_THIS), &closure->this_ptr);
524	}
525
526	if (arg_info &&
527		(closure->func.common.num_args ||
528		 (closure->func.common.fn_flags & ZEND_ACC_VARIADIC))) {
529		uint32_t i, num_args, required = closure->func.common.required_num_args;
530
531		array_init(&val);
532
533		num_args = closure->func.common.num_args;
534		if (closure->func.common.fn_flags & ZEND_ACC_VARIADIC) {
535			num_args++;
536		}
537		for (i = 0; i < num_args; i++) {
538			zend_string *name;
539			zval info;
540			if (arg_info->name) {
541				if (zstr_args) {
542					name = zend_strpprintf(0, "%s$%s",
543							arg_info->pass_by_reference ? "&" : "",
544							ZSTR_VAL(arg_info->name));
545				} else {
546					name = zend_strpprintf(0, "%s$%s",
547							arg_info->pass_by_reference ? "&" : "",
548							((zend_internal_arg_info*)arg_info)->name);
549				}
550			} else {
551				name = zend_strpprintf(0, "%s$param%d",
552						arg_info->pass_by_reference ? "&" : "",
553						i + 1);
554			}
555			ZVAL_NEW_STR(&info, zend_strpprintf(0, "%s", i >= required ? "<optional>" : "<required>"));
556			zend_hash_update(Z_ARRVAL(val), name, &info);
557			zend_string_release_ex(name, 0);
558			arg_info++;
559		}
560		zend_hash_str_update(debug_info, "parameter", sizeof("parameter")-1, &val);
561	}
562
563	return debug_info;
564}
565/* }}} */
566
567static HashTable *zend_closure_get_gc(zval *obj, zval **table, int *n) /* {{{ */
568{
569	zend_closure *closure = (zend_closure *)Z_OBJ_P(obj);
570
571	*table = Z_TYPE(closure->this_ptr) != IS_NULL ? &closure->this_ptr : NULL;
572	*n = Z_TYPE(closure->this_ptr) != IS_NULL ? 1 : 0;
573	return (closure->func.type == ZEND_USER_FUNCTION) ?
574		closure->func.op_array.static_variables : NULL;
575}
576/* }}} */
577
578/* {{{ proto Closure::__construct()
579   Private constructor preventing instantiation */
580ZEND_COLD ZEND_METHOD(Closure, __construct)
581{
582	zend_throw_error(NULL, "Instantiation of 'Closure' is not allowed");
583}
584/* }}} */
585
586ZEND_BEGIN_ARG_INFO_EX(arginfo_closure_bindto, 0, 0, 1)
587	ZEND_ARG_INFO(0, newthis)
588	ZEND_ARG_INFO(0, newscope)
589ZEND_END_ARG_INFO()
590
591ZEND_BEGIN_ARG_INFO_EX(arginfo_closure_bind, 0, 0, 2)
592	ZEND_ARG_INFO(0, closure)
593	ZEND_ARG_INFO(0, newthis)
594	ZEND_ARG_INFO(0, newscope)
595ZEND_END_ARG_INFO()
596
597ZEND_BEGIN_ARG_INFO_EX(arginfo_closure_call, 0, 0, 1)
598	ZEND_ARG_INFO(0, newthis)
599	ZEND_ARG_VARIADIC_INFO(0, parameters)
600ZEND_END_ARG_INFO()
601
602ZEND_BEGIN_ARG_INFO_EX(arginfo_closure_fromcallable, 0, 0, 1)
603	ZEND_ARG_INFO(0, callable)
604ZEND_END_ARG_INFO()
605
606static const zend_function_entry closure_functions[] = {
607	ZEND_ME(Closure, __construct, NULL, ZEND_ACC_PRIVATE)
608	ZEND_ME(Closure, bind, arginfo_closure_bind, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
609	ZEND_MALIAS(Closure, bindTo, bind, arginfo_closure_bindto, ZEND_ACC_PUBLIC)
610	ZEND_ME(Closure, call, arginfo_closure_call, ZEND_ACC_PUBLIC)
611	ZEND_ME(Closure, fromCallable, arginfo_closure_fromcallable, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
612	ZEND_FE_END
613};
614
615void zend_register_closure_ce(void) /* {{{ */
616{
617	zend_class_entry ce;
618
619	INIT_CLASS_ENTRY(ce, "Closure", closure_functions);
620	zend_ce_closure = zend_register_internal_class(&ce);
621	zend_ce_closure->ce_flags |= ZEND_ACC_FINAL;
622	zend_ce_closure->create_object = zend_closure_new;
623	zend_ce_closure->serialize = zend_class_serialize_deny;
624	zend_ce_closure->unserialize = zend_class_unserialize_deny;
625
626	memcpy(&closure_handlers, &std_object_handlers, sizeof(zend_object_handlers));
627	closure_handlers.free_obj = zend_closure_free_storage;
628	closure_handlers.get_constructor = zend_closure_get_constructor;
629	closure_handlers.get_method = zend_closure_get_method;
630	closure_handlers.write_property = zend_closure_write_property;
631	closure_handlers.read_property = zend_closure_read_property;
632	closure_handlers.get_property_ptr_ptr = zend_closure_get_property_ptr_ptr;
633	closure_handlers.has_property = zend_closure_has_property;
634	closure_handlers.unset_property = zend_closure_unset_property;
635	closure_handlers.compare_objects = zend_closure_compare_objects;
636	closure_handlers.clone_obj = zend_closure_clone;
637	closure_handlers.get_debug_info = zend_closure_get_debug_info;
638	closure_handlers.get_closure = zend_closure_get_closure;
639	closure_handlers.get_gc = zend_closure_get_gc;
640}
641/* }}} */
642
643static ZEND_NAMED_FUNCTION(zend_closure_internal_handler) /* {{{ */
644{
645	zend_closure *closure = (zend_closure*)ZEND_CLOSURE_OBJECT(EX(func));
646	closure->orig_internal_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU);
647	OBJ_RELEASE((zend_object*)closure);
648	EX(func) = NULL;
649}
650/* }}} */
651
652ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr) /* {{{ */
653{
654	zend_closure *closure;
655
656	object_init_ex(res, zend_ce_closure);
657
658	closure = (zend_closure *)Z_OBJ_P(res);
659
660	if ((scope == NULL) && this_ptr && (Z_TYPE_P(this_ptr) != IS_UNDEF)) {
661		/* use dummy scope if we're binding an object without specifying a scope */
662		/* maybe it would be better to create one for this purpose */
663		scope = zend_ce_closure;
664	}
665
666	if (func->type == ZEND_USER_FUNCTION) {
667		memcpy(&closure->func, func, sizeof(zend_op_array));
668		closure->func.common.fn_flags |= ZEND_ACC_CLOSURE;
669		closure->func.common.fn_flags &= ~ZEND_ACC_IMMUTABLE;
670		if (closure->func.op_array.static_variables) {
671			closure->func.op_array.static_variables =
672				zend_array_dup(closure->func.op_array.static_variables);
673		}
674
675		/* Runtime cache is scope-dependent, so we cannot reuse it if the scope changed */
676		if (!closure->func.op_array.run_time_cache
677			|| func->common.scope != scope
678			|| (func->common.fn_flags & ZEND_ACC_NO_RT_ARENA)
679		) {
680			if (!func->op_array.run_time_cache
681			 && (func->common.fn_flags & ZEND_ACC_CLOSURE)
682			 && !(func->common.fn_flags & ZEND_ACC_IMMUTABLE)) {
683				/* If a real closure is used for the first time, we create a shared runtime cache
684				 * and remember which scope it is for. */
685				func->common.scope = scope;
686				func->op_array.run_time_cache = zend_arena_alloc(&CG(arena), func->op_array.cache_size);
687				closure->func.op_array.run_time_cache = func->op_array.run_time_cache;
688			} else {
689				/* Otherwise, we use a non-shared runtime cache */
690				closure->func.op_array.run_time_cache = emalloc(func->op_array.cache_size);
691				closure->func.op_array.fn_flags |= ZEND_ACC_NO_RT_ARENA;
692			}
693			memset(closure->func.op_array.run_time_cache, 0, func->op_array.cache_size);
694		}
695		if (closure->func.op_array.refcount) {
696			(*closure->func.op_array.refcount)++;
697		}
698	} else {
699		memcpy(&closure->func, func, sizeof(zend_internal_function));
700		closure->func.common.fn_flags |= ZEND_ACC_CLOSURE;
701		/* wrap internal function handler to avoid memory leak */
702		if (UNEXPECTED(closure->func.internal_function.handler == zend_closure_internal_handler)) {
703			/* avoid infinity recursion, by taking handler from nested closure */
704			zend_closure *nested = (zend_closure*)((char*)func - XtOffsetOf(zend_closure, func));
705			ZEND_ASSERT(nested->std.ce == zend_ce_closure);
706			closure->orig_internal_handler = nested->orig_internal_handler;
707		} else {
708			closure->orig_internal_handler = closure->func.internal_function.handler;
709		}
710		closure->func.internal_function.handler = zend_closure_internal_handler;
711		if (!func->common.scope) {
712			/* if it's a free function, we won't set scope & this since they're meaningless */
713			this_ptr = NULL;
714			scope = NULL;
715		}
716	}
717
718	ZVAL_UNDEF(&closure->this_ptr);
719	/* Invariant:
720	 * If the closure is unscoped or static, it has no bound object. */
721	closure->func.common.scope = scope;
722	closure->called_scope = called_scope;
723	if (scope) {
724		closure->func.common.fn_flags |= ZEND_ACC_PUBLIC;
725		if (this_ptr && Z_TYPE_P(this_ptr) == IS_OBJECT && (closure->func.common.fn_flags & ZEND_ACC_STATIC) == 0) {
726			ZVAL_COPY(&closure->this_ptr, this_ptr);
727		}
728	}
729}
730/* }}} */
731
732ZEND_API void zend_create_fake_closure(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr) /* {{{ */
733{
734	zend_closure *closure;
735
736	zend_create_closure(res, func, scope, called_scope, this_ptr);
737
738	closure = (zend_closure *)Z_OBJ_P(res);
739	closure->func.common.fn_flags |= ZEND_ACC_FAKE_CLOSURE;
740}
741/* }}} */
742
743void zend_closure_bind_var(zval *closure_zv, zend_string *var_name, zval *var) /* {{{ */
744{
745	zend_closure *closure = (zend_closure *) Z_OBJ_P(closure_zv);
746	HashTable *static_variables = closure->func.op_array.static_variables;
747	zend_hash_update(static_variables, var_name, var);
748}
749/* }}} */
750
751void zend_closure_bind_var_ex(zval *closure_zv, uint32_t offset, zval *val) /* {{{ */
752{
753	zend_closure *closure = (zend_closure *) Z_OBJ_P(closure_zv);
754	HashTable *static_variables = closure->func.op_array.static_variables;
755	zval *var = (zval*)((char*)static_variables->arData + offset);
756	zval_ptr_dtor(var);
757	ZVAL_COPY_VALUE(var, val);
758}
759/* }}} */
760
761/*
762 * Local variables:
763 * tab-width: 4
764 * c-basic-offset: 4
765 * indent-tabs-mode: t
766 * End:
767 * vim600: sw=4 ts=4 fdm=marker
768 * vim<600: sw=4 ts=4
769 */
770