Annotation of embedaddon/php/Zend/zend_closures.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | Zend Engine |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1998-2012 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: zend_closures.c 321634 2012-01-01 13:15:04Z felipe $ */
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: HashTable *debug_info;
41: } zend_closure;
42:
43: /* non-static since it needs to be referenced */
44: ZEND_API zend_class_entry *zend_ce_closure;
45: static zend_object_handlers closure_handlers;
46:
47: ZEND_METHOD(Closure, __invoke) /* {{{ */
48: {
49: zend_function *func = EG(current_execute_data)->function_state.function;
50: zval ***arguments;
51: zval *closure_result_ptr = NULL;
52:
53: arguments = emalloc(sizeof(zval**) * ZEND_NUM_ARGS());
54: if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), arguments) == FAILURE) {
55: efree(arguments);
56: zend_error(E_RECOVERABLE_ERROR, "Cannot get arguments for calling closure");
57: RETVAL_FALSE;
58: } else if (call_user_function_ex(CG(function_table), NULL, this_ptr, &closure_result_ptr, ZEND_NUM_ARGS(), arguments, 1, NULL TSRMLS_CC) == FAILURE) {
59: RETVAL_FALSE;
60: } else if (closure_result_ptr) {
61: if (Z_ISREF_P(closure_result_ptr) && return_value_ptr) {
62: if (return_value) {
63: zval_ptr_dtor(&return_value);
64: }
65: *return_value_ptr = closure_result_ptr;
66: } else {
67: RETVAL_ZVAL(closure_result_ptr, 1, 1);
68: }
69: }
70: efree(arguments);
71:
72: /* destruct the function also, then - we have allocated it in get_method */
73: efree(func->internal_function.function_name);
74: efree(func);
75: }
76: /* }}} */
77:
78: static zend_function *zend_closure_get_constructor(zval *object TSRMLS_DC) /* {{{ */
79: {
80: zend_error(E_RECOVERABLE_ERROR, "Instantiation of 'Closure' is not allowed");
81: return NULL;
82: }
83: /* }}} */
84:
85: static int zend_closure_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
86: {
87: return (Z_OBJ_HANDLE_P(o1) != Z_OBJ_HANDLE_P(o2));
88: }
89: /* }}} */
90:
91: ZEND_API zend_function *zend_get_closure_invoke_method(zval *obj TSRMLS_DC) /* {{{ */
92: {
93: zend_closure *closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
94: zend_function *invoke = (zend_function*)emalloc(sizeof(zend_function));
95:
96: invoke->common = closure->func.common;
97: invoke->type = ZEND_INTERNAL_FUNCTION;
98: invoke->internal_function.fn_flags = ZEND_ACC_PUBLIC | ZEND_ACC_CALL_VIA_HANDLER;
99: invoke->internal_function.handler = ZEND_MN(Closure___invoke);
100: invoke->internal_function.module = 0;
101: invoke->internal_function.scope = zend_ce_closure;
102: invoke->internal_function.function_name = estrndup(ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1);
103: return invoke;
104: }
105: /* }}} */
106:
107: ZEND_API const zend_function *zend_get_closure_method_def(zval *obj TSRMLS_DC) /* {{{ */
108: {
109: zend_closure *closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
110: return &closure->func;
111: }
112: /* }}} */
113:
114: static zend_function *zend_closure_get_method(zval **object_ptr, char *method_name, int method_len TSRMLS_DC) /* {{{ */
115: {
116: char *lc_name;
117: ALLOCA_FLAG(use_heap)
118:
119: lc_name = do_alloca(method_len + 1, use_heap);
120: zend_str_tolower_copy(lc_name, method_name, method_len);
121: if ((method_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) &&
122: memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
123: ) {
124: free_alloca(lc_name, use_heap);
125: return zend_get_closure_invoke_method(*object_ptr TSRMLS_CC);
126: }
127: free_alloca(lc_name, use_heap);
128: return NULL;
129: }
130: /* }}} */
131:
132: static zval *zend_closure_read_property(zval *object, zval *member, int type TSRMLS_DC) /* {{{ */
133: {
134: ZEND_CLOSURE_PROPERTY_ERROR();
135: Z_ADDREF(EG(uninitialized_zval));
136: return &EG(uninitialized_zval);
137: }
138: /* }}} */
139:
140: static void zend_closure_write_property(zval *object, zval *member, zval *value TSRMLS_DC) /* {{{ */
141: {
142: ZEND_CLOSURE_PROPERTY_ERROR();
143: }
144: /* }}} */
145:
146: static zval **zend_closure_get_property_ptr_ptr(zval *object, zval *member TSRMLS_DC) /* {{{ */
147: {
148: ZEND_CLOSURE_PROPERTY_ERROR();
149: return NULL;
150: }
151: /* }}} */
152:
153: static int zend_closure_has_property(zval *object, zval *member, int has_set_exists TSRMLS_DC) /* {{{ */
154: {
155: if (has_set_exists != 2) {
156: ZEND_CLOSURE_PROPERTY_ERROR();
157: }
158: return 0;
159: }
160: /* }}} */
161:
162: static void zend_closure_unset_property(zval *object, zval *member TSRMLS_DC) /* {{{ */
163: {
164: ZEND_CLOSURE_PROPERTY_ERROR();
165: }
166: /* }}} */
167:
168: static void zend_closure_free_storage(void *object TSRMLS_DC) /* {{{ */
169: {
170: zend_closure *closure = (zend_closure *)object;
171:
172: zend_object_std_dtor(&closure->std TSRMLS_CC);
173:
174: if (closure->func.type == ZEND_USER_FUNCTION) {
175: zend_execute_data *ex = EG(current_execute_data);
176: while (ex) {
177: if (ex->op_array == &closure->func.op_array) {
178: zend_error(E_ERROR, "Cannot destroy active lambda function");
179: }
180: ex = ex->prev_execute_data;
181: }
182: destroy_op_array(&closure->func.op_array TSRMLS_CC);
183: }
184:
185: if (closure->debug_info != NULL) {
186: zend_hash_destroy(closure->debug_info);
187: efree(closure->debug_info);
188: }
189:
190: efree(closure);
191: }
192: /* }}} */
193:
194: static zend_object_value zend_closure_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
195: {
196: zend_closure *closure;
197: zend_object_value object;
198:
199: closure = emalloc(sizeof(zend_closure));
200: memset(closure, 0, sizeof(zend_closure));
201:
202: zend_object_std_init(&closure->std, class_type TSRMLS_CC);
203:
204: 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);
205: object.handlers = &closure_handlers;
206:
207: return object;
208: }
209: /* }}} */
210:
211: int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zval **zobj_ptr TSRMLS_DC) /* {{{ */
212: {
213: zend_closure *closure;
214:
215: if (Z_TYPE_P(obj) != IS_OBJECT) {
216: return FAILURE;
217: }
218:
219: closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
220: *fptr_ptr = &closure->func;
221:
222: if (zobj_ptr) {
223: *zobj_ptr = NULL;
224: }
225: *ce_ptr = NULL;
226: return SUCCESS;
227: }
228: /* }}} */
229:
230: static HashTable *zend_closure_get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
231: {
232: zend_closure *closure = (zend_closure *)zend_object_store_get_object(object TSRMLS_CC);
233: zval *val;
234: struct _zend_arg_info *arg_info = closure->func.common.arg_info;
235:
236: *is_temp = 0;
237:
238: if (closure->debug_info == NULL) {
239: ALLOC_HASHTABLE(closure->debug_info);
240: zend_hash_init(closure->debug_info, 1, NULL, ZVAL_PTR_DTOR, 0);
241: }
242: if (closure->debug_info->nApplyCount == 0) {
243: if (closure->func.type == ZEND_USER_FUNCTION && closure->func.op_array.static_variables) {
244: HashTable *static_variables = closure->func.op_array.static_variables;
245: MAKE_STD_ZVAL(val);
246: array_init(val);
247: zend_hash_copy(Z_ARRVAL_P(val), static_variables, (copy_ctor_func_t)zval_add_ref, NULL, sizeof(zval*));
248: zend_symtable_update(closure->debug_info, "static", sizeof("static"), (void *) &val, sizeof(zval *), NULL);
249: }
250:
251: if (arg_info) {
252: zend_uint i, required = closure->func.common.required_num_args;
253:
254: MAKE_STD_ZVAL(val);
255: array_init(val);
256:
257: for (i = 0; i < closure->func.common.num_args; i++) {
258: char *name, *info;
259: int name_len, info_len;
260: if (arg_info->name) {
261: name_len = zend_spprintf(&name, 0, "%s$%s",
262: arg_info->pass_by_reference ? "&" : "",
263: arg_info->name);
264: } else {
265: name_len = zend_spprintf(&name, 0, "%s$param%d",
266: arg_info->pass_by_reference ? "&" : "",
267: i + 1);
268: }
269: info_len = zend_spprintf(&info, 0, "%s",
270: i >= required ? "<optional>" : "<required>");
271: add_assoc_stringl_ex(val, name, name_len + 1, info, info_len, 0);
272: efree(name);
273: arg_info++;
274: }
275: zend_symtable_update(closure->debug_info, "parameter", sizeof("parameter"), (void *) &val, sizeof(zval *), NULL);
276: }
277: }
278:
279: return closure->debug_info;
280: }
281: /* }}} */
282:
283: static HashTable *zend_closure_get_properties(zval *obj TSRMLS_DC) /* {{{ */
284: {
285: zend_closure *closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
286:
287: if (GC_G(gc_active)) {
288: return (closure->func.type == ZEND_USER_FUNCTION) ? closure->func.op_array.static_variables : NULL;
289: }
290:
291: return closure->std.properties;
292: }
293: /* }}} */
294:
295: /* {{{ proto Closure::__construct()
296: Private constructor preventing instantiation */
297: ZEND_METHOD(Closure, __construct)
298: {
299: zend_error(E_RECOVERABLE_ERROR, "Instantiation of 'Closure' is not allowed");
300: }
301: /* }}} */
302:
303: static const zend_function_entry closure_functions[] = {
304: ZEND_ME(Closure, __construct, NULL, ZEND_ACC_PRIVATE)
305: {NULL, NULL, NULL}
306: };
307:
308: void zend_register_closure_ce(TSRMLS_D) /* {{{ */
309: {
310: zend_class_entry ce;
311:
312: INIT_CLASS_ENTRY(ce, "Closure", closure_functions);
313: zend_ce_closure = zend_register_internal_class(&ce TSRMLS_CC);
314: zend_ce_closure->ce_flags |= ZEND_ACC_FINAL_CLASS;
315: zend_ce_closure->create_object = zend_closure_new;
316: zend_ce_closure->serialize = zend_class_serialize_deny;
317: zend_ce_closure->unserialize = zend_class_unserialize_deny;
318:
319: memcpy(&closure_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
320: closure_handlers.get_constructor = zend_closure_get_constructor;
321: closure_handlers.get_method = zend_closure_get_method;
322: closure_handlers.write_property = zend_closure_write_property;
323: closure_handlers.read_property = zend_closure_read_property;
324: closure_handlers.get_property_ptr_ptr = zend_closure_get_property_ptr_ptr;
325: closure_handlers.has_property = zend_closure_has_property;
326: closure_handlers.unset_property = zend_closure_unset_property;
327: closure_handlers.compare_objects = zend_closure_compare_objects;
328: closure_handlers.clone_obj = NULL;
329: closure_handlers.get_debug_info = zend_closure_get_debug_info;
330: closure_handlers.get_closure = zend_closure_get_closure;
331: closure_handlers.get_properties = zend_closure_get_properties;
332: }
333: /* }}} */
334:
335: static int zval_copy_static_var(zval **p TSRMLS_DC, int num_args, va_list args, zend_hash_key *key) /* {{{ */
336: {
337: HashTable *target = va_arg(args, HashTable*);
338: zend_bool is_ref;
339: zval *tmp;
340:
341: if (Z_TYPE_PP(p) & (IS_LEXICAL_VAR|IS_LEXICAL_REF)) {
342: is_ref = Z_TYPE_PP(p) & IS_LEXICAL_REF;
343:
344: if (!EG(active_symbol_table)) {
345: zend_rebuild_symbol_table(TSRMLS_C);
346: }
347: if (zend_hash_quick_find(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, (void **) &p) == FAILURE) {
348: if (is_ref) {
349: ALLOC_INIT_ZVAL(tmp);
350: Z_SET_ISREF_P(tmp);
351: zend_hash_quick_add(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, &tmp, sizeof(zval*), (void**)&p);
352: } else {
353: tmp = EG(uninitialized_zval_ptr);
354: zend_error(E_NOTICE,"Undefined variable: %s", key->arKey);
355: }
356: } else {
357: if (is_ref) {
358: SEPARATE_ZVAL_TO_MAKE_IS_REF(p);
359: tmp = *p;
360: } else if (Z_ISREF_PP(p)) {
361: ALLOC_INIT_ZVAL(tmp);
362: *tmp = **p;
363: zval_copy_ctor(tmp);
364: Z_SET_REFCOUNT_P(tmp, 0);
365: Z_UNSET_ISREF_P(tmp);
366: } else {
367: tmp = *p;
368: }
369: }
370: } else {
371: tmp = *p;
372: }
373: if (zend_hash_quick_add(target, key->arKey, key->nKeyLength, key->h, &tmp, sizeof(zval*), NULL) == SUCCESS) {
374: Z_ADDREF_P(tmp);
375: }
376: return ZEND_HASH_APPLY_KEEP;
377: }
378: /* }}} */
379:
380: ZEND_API void zend_create_closure(zval *res, zend_function *func TSRMLS_DC) /* {{{ */
381: {
382: zend_closure *closure;
383:
384: object_init_ex(res, zend_ce_closure);
385:
386: closure = (zend_closure *)zend_object_store_get_object(res TSRMLS_CC);
387:
388: closure->func = *func;
389: closure->func.common.prototype = NULL;
390:
391: if (closure->func.type == ZEND_USER_FUNCTION) {
392: if (closure->func.op_array.static_variables) {
393: HashTable *static_variables = closure->func.op_array.static_variables;
394:
395: ALLOC_HASHTABLE(closure->func.op_array.static_variables);
396: zend_hash_init(closure->func.op_array.static_variables, zend_hash_num_elements(static_variables), NULL, ZVAL_PTR_DTOR, 0);
397: zend_hash_apply_with_arguments(static_variables TSRMLS_CC, (apply_func_args_t)zval_copy_static_var, 1, closure->func.op_array.static_variables);
398: }
399: (*closure->func.op_array.refcount)++;
400: }
401:
402: closure->func.common.scope = NULL;
403: }
404: /* }}} */
405:
406: /*
407: * Local variables:
408: * tab-width: 4
409: * c-basic-offset: 4
410: * indent-tabs-mode: t
411: * End:
412: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zend_closures.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / Zend