/src/php-src/Zend/zend_generators.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | +----------------------------------------------------------------------+ |
3 | | | Zend Engine | |
4 | | +----------------------------------------------------------------------+ |
5 | | | Copyright (c) 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: Nikita Popov <nikic@php.net> | |
16 | | | Bob Weinand <bobwei9@hotmail.com> | |
17 | | +----------------------------------------------------------------------+ |
18 | | */ |
19 | | |
20 | | #include "zend.h" |
21 | | #include "zend_API.h" |
22 | | #include "zend_hash.h" |
23 | | #include "zend_interfaces.h" |
24 | | #include "zend_exceptions.h" |
25 | | #include "zend_generators.h" |
26 | | #include "zend_closures.h" |
27 | | #include "zend_generators_arginfo.h" |
28 | | #include "zend_observer.h" |
29 | | #include "zend_vm_opcodes.h" |
30 | | |
31 | | ZEND_API zend_class_entry *zend_ce_generator; |
32 | | ZEND_API zend_class_entry *zend_ce_ClosedGeneratorException; |
33 | | static zend_object_handlers zend_generator_handlers; |
34 | | |
35 | | static zend_object *zend_generator_create(zend_class_entry *class_type); |
36 | | |
37 | | ZEND_API void zend_generator_restore_call_stack(zend_generator *generator) /* {{{ */ |
38 | 299 | { |
39 | 299 | zend_execute_data *call, *new_call, *prev_call = NULL; |
40 | | |
41 | 299 | call = generator->frozen_call_stack; |
42 | 325 | do { |
43 | 325 | new_call = zend_vm_stack_push_call_frame( |
44 | 325 | (ZEND_CALL_INFO(call) & ~ZEND_CALL_ALLOCATED), |
45 | 325 | call->func, |
46 | 325 | ZEND_CALL_NUM_ARGS(call), |
47 | 325 | Z_PTR(call->This)); |
48 | 325 | memcpy(((zval*)new_call) + ZEND_CALL_FRAME_SLOT, ((zval*)call) + ZEND_CALL_FRAME_SLOT, ZEND_CALL_NUM_ARGS(call) * sizeof(zval)); |
49 | 325 | new_call->extra_named_params = call->extra_named_params; |
50 | 325 | new_call->prev_execute_data = prev_call; |
51 | 325 | prev_call = new_call; |
52 | | |
53 | 325 | call = call->prev_execute_data; |
54 | 325 | } while (call); |
55 | 299 | generator->execute_data->call = prev_call; |
56 | 299 | efree(generator->frozen_call_stack); |
57 | 299 | generator->frozen_call_stack = NULL; |
58 | 299 | } |
59 | | /* }}} */ |
60 | | |
61 | | ZEND_API zend_execute_data* zend_generator_freeze_call_stack(zend_execute_data *execute_data) /* {{{ */ |
62 | 303 | { |
63 | 303 | size_t used_stack; |
64 | 303 | zend_execute_data *call, *new_call, *prev_call = NULL; |
65 | 303 | zval *stack; |
66 | | |
67 | | /* calculate required stack size */ |
68 | 303 | used_stack = 0; |
69 | 303 | call = EX(call); |
70 | 329 | do { |
71 | 329 | used_stack += ZEND_CALL_FRAME_SLOT + ZEND_CALL_NUM_ARGS(call); |
72 | 329 | call = call->prev_execute_data; |
73 | 329 | } while (call); |
74 | | |
75 | 303 | stack = emalloc(used_stack * sizeof(zval)); |
76 | | |
77 | | /* save stack, linking frames in reverse order */ |
78 | 303 | call = EX(call); |
79 | 329 | do { |
80 | 329 | size_t frame_size = ZEND_CALL_FRAME_SLOT + ZEND_CALL_NUM_ARGS(call); |
81 | | |
82 | 329 | new_call = (zend_execute_data*)(stack + used_stack - frame_size); |
83 | 329 | memcpy(new_call, call, frame_size * sizeof(zval)); |
84 | 329 | used_stack -= frame_size; |
85 | 329 | new_call->prev_execute_data = prev_call; |
86 | 329 | prev_call = new_call; |
87 | | |
88 | 329 | new_call = call->prev_execute_data; |
89 | 329 | zend_vm_stack_free_call_frame(call); |
90 | 329 | call = new_call; |
91 | 329 | } while (call); |
92 | | |
93 | 303 | execute_data->call = NULL; |
94 | 303 | ZEND_ASSERT(prev_call == (zend_execute_data*)stack); |
95 | | |
96 | 303 | return prev_call; |
97 | 303 | } |
98 | | /* }}} */ |
99 | | |
100 | | static zend_execute_data* zend_generator_revert_call_stack(zend_execute_data *call) |
101 | 572 | { |
102 | 572 | zend_execute_data *prev = NULL; |
103 | | |
104 | 648 | do { |
105 | 648 | zend_execute_data *next = call->prev_execute_data; |
106 | 648 | call->prev_execute_data = prev; |
107 | 648 | prev = call; |
108 | 648 | call = next; |
109 | 648 | } while (call); |
110 | | |
111 | 572 | return prev; |
112 | 572 | } |
113 | | |
114 | | static void zend_generator_cleanup_unfinished_execution( |
115 | | zend_generator *generator, zend_execute_data *execute_data, uint32_t catch_op_num) /* {{{ */ |
116 | 2.16k | { |
117 | 2.16k | zend_op_array *op_array = &execute_data->func->op_array; |
118 | 2.16k | if (execute_data->opline != op_array->opcodes) { |
119 | 1.23k | uint32_t op_num = execute_data->opline - op_array->opcodes; |
120 | | |
121 | 1.23k | if (UNEXPECTED(generator->frozen_call_stack)) { |
122 | | /* Temporarily restore generator->execute_data if it has been NULLed out already. */ |
123 | 93 | zend_execute_data *save_ex = generator->execute_data; |
124 | 93 | generator->execute_data = execute_data; |
125 | 93 | zend_generator_restore_call_stack(generator); |
126 | 93 | generator->execute_data = save_ex; |
127 | 93 | } |
128 | | |
129 | 1.23k | zend_cleanup_unfinished_execution(execute_data, op_num, catch_op_num); |
130 | 1.23k | } |
131 | 2.16k | } |
132 | | /* }}} */ |
133 | | |
134 | | ZEND_API void zend_generator_close(zend_generator *generator, bool finished_execution) /* {{{ */ |
135 | 12.3k | { |
136 | 12.3k | if (EXPECTED(generator->execute_data)) { |
137 | 4.94k | zend_execute_data *execute_data = generator->execute_data; |
138 | | /* Null out execute_data early, to prevent double frees if GC runs while we're |
139 | | * already cleaning up execute_data. */ |
140 | 4.94k | generator->execute_data = NULL; |
141 | | |
142 | 4.94k | if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { |
143 | 18 | zend_clean_and_cache_symbol_table(execute_data->symbol_table); |
144 | 18 | } |
145 | | /* always free the CV's, in the symtable are only not-free'd IS_INDIRECT's */ |
146 | 4.94k | zend_free_compiled_variables(execute_data); |
147 | 4.94k | if (EX_CALL_INFO() & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { |
148 | 0 | zend_free_extra_named_params(execute_data->extra_named_params); |
149 | 0 | } |
150 | | |
151 | 4.94k | if (EX_CALL_INFO() & ZEND_CALL_RELEASE_THIS) { |
152 | 172 | OBJ_RELEASE(Z_OBJ(execute_data->This)); |
153 | 172 | } |
154 | | |
155 | | /* A fatal error / die occurred during the generator execution. |
156 | | * Trying to clean up the stack may not be safe in this case. */ |
157 | 4.94k | if (UNEXPECTED(CG(unclean_shutdown))) { |
158 | 810 | generator->execute_data = NULL; |
159 | 810 | return; |
160 | 810 | } |
161 | | |
162 | 4.13k | zend_vm_stack_free_extra_args(execute_data); |
163 | | |
164 | | /* Some cleanups are only necessary if the generator was closed |
165 | | * before it could finish execution (reach a return statement). */ |
166 | 4.13k | if (UNEXPECTED(!finished_execution)) { |
167 | 2.02k | zend_generator_cleanup_unfinished_execution(generator, execute_data, 0); |
168 | 2.02k | } |
169 | | |
170 | 4.13k | efree(execute_data); |
171 | 4.13k | } |
172 | 12.3k | } |
173 | | /* }}} */ |
174 | | |
175 | | static void zend_generator_remove_child(zend_generator_node *node, zend_generator *child) |
176 | 1.25k | { |
177 | 1.25k | ZEND_ASSERT(node->children >= 1); |
178 | 1.25k | if (node->children == 1) { |
179 | 1.12k | node->child.single = NULL; |
180 | 1.12k | } else { |
181 | 134 | HashTable *ht = node->child.ht; |
182 | 134 | zend_hash_index_del(ht, (zend_ulong) child); |
183 | 134 | if (node->children == 2) { |
184 | 134 | zend_generator *other_child; |
185 | 134 | ZEND_HASH_FOREACH_PTR(ht, other_child) { |
186 | 134 | node->child.single = other_child; |
187 | 134 | break; |
188 | 341 | } ZEND_HASH_FOREACH_END(); |
189 | 134 | zend_hash_destroy(ht); |
190 | 134 | efree(ht); |
191 | 134 | } |
192 | 134 | } |
193 | 1.25k | node->children--; |
194 | 1.25k | } |
195 | | |
196 | 7.01k | static zend_always_inline zend_generator *clear_link_to_leaf(zend_generator *generator) { |
197 | 7.01k | ZEND_ASSERT(!generator->node.parent); |
198 | 7.01k | zend_generator *leaf = generator->node.ptr.leaf; |
199 | 7.01k | if (leaf) { |
200 | 1.63k | leaf->node.ptr.root = NULL; |
201 | 1.63k | generator->node.ptr.leaf = NULL; |
202 | 1.63k | return leaf; |
203 | 1.63k | } |
204 | 5.38k | return NULL; |
205 | 7.01k | } |
206 | | |
207 | 650 | static zend_always_inline void clear_link_to_root(zend_generator *generator) { |
208 | 650 | ZEND_ASSERT(generator->node.parent); |
209 | 650 | if (generator->node.ptr.root) { |
210 | 650 | generator->node.ptr.root->node.ptr.leaf = NULL; |
211 | 650 | generator->node.ptr.root = NULL; |
212 | 650 | } |
213 | 650 | } |
214 | | |
215 | | /* Check if the node 'generator' is running in a fiber */ |
216 | 168 | static inline bool check_node_running_in_fiber(zend_generator *generator) { |
217 | 168 | ZEND_ASSERT(generator->execute_data); |
218 | | |
219 | 168 | if (EXPECTED(generator->flags & ZEND_GENERATOR_IN_FIBER)) { |
220 | 127 | return true; |
221 | 127 | } |
222 | | |
223 | 41 | if (EXPECTED(generator->node.children == 0)) { |
224 | 24 | return false; |
225 | 24 | } |
226 | | |
227 | 17 | if (generator->node.children == 1) { |
228 | 5 | return check_node_running_in_fiber(generator->node.child.single); |
229 | 5 | } |
230 | | |
231 | 12 | zend_generator *child; |
232 | 50 | ZEND_HASH_FOREACH_PTR(generator->node.child.ht, child) { |
233 | 50 | if (check_node_running_in_fiber(child)) { |
234 | 12 | return true; |
235 | 12 | } |
236 | 50 | } ZEND_HASH_FOREACH_END(); |
237 | | |
238 | 0 | return false; |
239 | 12 | } |
240 | | |
241 | | static void zend_generator_dtor_storage(zend_object *object) /* {{{ */ |
242 | 4.95k | { |
243 | 4.95k | zend_generator *generator = (zend_generator*) object; |
244 | 4.95k | zend_generator *current_generator = zend_generator_get_current(generator); |
245 | 4.95k | zend_execute_data *ex = generator->execute_data; |
246 | 4.95k | uint32_t op_num, try_catch_offset; |
247 | 4.95k | int i; |
248 | | |
249 | | /* If current_generator is running in a fiber, there are 2 cases to consider: |
250 | | * - If generator is also marked with ZEND_GENERATOR_IN_FIBER, then the |
251 | | * entire path from current_generator to generator is executing in a |
252 | | * fiber. Do not dtor now: These will be dtor when terminating the fiber. |
253 | | * - If generator is not marked with ZEND_GENERATOR_IN_FIBER, and has a |
254 | | * child marked with ZEND_GENERATOR_IN_FIBER, then this an intermediate |
255 | | * node of case 1. Otherwise generator is not executing in a fiber and we |
256 | | * can dtor. |
257 | | */ |
258 | 4.95k | if (current_generator->flags & ZEND_GENERATOR_IN_FIBER) { |
259 | 144 | if (check_node_running_in_fiber(generator)) { |
260 | | /* Prevent finally blocks from yielding */ |
261 | 127 | generator->flags |= ZEND_GENERATOR_FORCED_CLOSE; |
262 | 127 | return; |
263 | 127 | } |
264 | 144 | } |
265 | | |
266 | | /* leave yield from mode to properly allow finally execution */ |
267 | 4.82k | if (UNEXPECTED(Z_TYPE(generator->values) != IS_UNDEF)) { |
268 | 44 | zval_ptr_dtor(&generator->values); |
269 | 44 | ZVAL_UNDEF(&generator->values); |
270 | 44 | } |
271 | | |
272 | 4.82k | zend_generator *parent = generator->node.parent; |
273 | 4.82k | if (parent) { |
274 | 650 | zend_generator_remove_child(&parent->node, generator); |
275 | 650 | clear_link_to_root(generator); |
276 | 650 | generator->node.parent = NULL; |
277 | 650 | OBJ_RELEASE(&parent->std); |
278 | 4.17k | } else { |
279 | 4.17k | clear_link_to_leaf(generator); |
280 | 4.17k | } |
281 | | |
282 | 4.82k | if (EXPECTED(!ex) || EXPECTED(!(ex->func->op_array.fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK)) |
283 | 4.82k | || CG(unclean_shutdown)) { |
284 | 4.64k | zend_generator_close(generator, 0); |
285 | 4.64k | return; |
286 | 4.64k | } |
287 | | |
288 | 180 | op_num = ex->opline - ex->func->op_array.opcodes; |
289 | 180 | try_catch_offset = -1; |
290 | | |
291 | | /* Find the innermost try/catch that we are inside of. */ |
292 | 386 | for (i = 0; i < ex->func->op_array.last_try_catch; i++) { |
293 | 224 | zend_try_catch_element *try_catch = &ex->func->op_array.try_catch_array[i]; |
294 | 224 | if (op_num < try_catch->try_op) { |
295 | 18 | break; |
296 | 18 | } |
297 | 206 | if (op_num < try_catch->catch_op || op_num < try_catch->finally_end) { |
298 | 206 | try_catch_offset = i; |
299 | 206 | } |
300 | 206 | } |
301 | | |
302 | | /* Walk try/catch/finally structures upwards, performing the necessary actions. */ |
303 | 219 | while (try_catch_offset != (uint32_t) -1) { |
304 | 181 | zend_try_catch_element *try_catch = &ex->func->op_array.try_catch_array[try_catch_offset]; |
305 | | |
306 | 181 | if (op_num < try_catch->finally_op) { |
307 | | /* Go to finally block */ |
308 | 142 | zval *fast_call = |
309 | 142 | ZEND_CALL_VAR(ex, ex->func->op_array.opcodes[try_catch->finally_end].op1.var); |
310 | | |
311 | 142 | zend_generator_cleanup_unfinished_execution(generator, ex, try_catch->finally_op); |
312 | 142 | zend_object *old_exception = EG(exception); |
313 | 142 | const zend_op *old_opline_before_exception = EG(opline_before_exception); |
314 | 142 | EG(exception) = NULL; |
315 | 142 | Z_OBJ_P(fast_call) = NULL; |
316 | 142 | Z_OPLINE_NUM_P(fast_call) = (uint32_t)-1; |
317 | | |
318 | | /* -1 because zend_generator_resume() will increment it */ |
319 | 142 | ex->opline = &ex->func->op_array.opcodes[try_catch->finally_op] - 1; |
320 | 142 | generator->flags |= ZEND_GENERATOR_FORCED_CLOSE; |
321 | 142 | zend_generator_resume(generator); |
322 | | |
323 | 142 | if (old_exception) { |
324 | 56 | EG(opline_before_exception) = old_opline_before_exception; |
325 | 56 | if (EG(exception)) { |
326 | 5 | zend_exception_set_previous(EG(exception), old_exception); |
327 | 51 | } else { |
328 | 51 | EG(exception) = old_exception; |
329 | 51 | } |
330 | 56 | } |
331 | | |
332 | | /* TODO: If we hit another yield inside try/finally, |
333 | | * should we also jump to the next finally block? */ |
334 | 142 | break; |
335 | 142 | } else if (op_num < try_catch->finally_end) { |
336 | 39 | zval *fast_call = |
337 | 39 | ZEND_CALL_VAR(ex, ex->func->op_array.opcodes[try_catch->finally_end].op1.var); |
338 | | /* Clean up incomplete return statement */ |
339 | 39 | if (Z_OPLINE_NUM_P(fast_call) != (uint32_t) -1) { |
340 | 23 | zend_op *retval_op = &ex->func->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)]; |
341 | 23 | if (retval_op->op2_type & (IS_TMP_VAR | IS_VAR)) { |
342 | 21 | zval_ptr_dtor(ZEND_CALL_VAR(ex, retval_op->op2.var)); |
343 | 21 | } |
344 | 23 | } |
345 | | /* Clean up backed-up exception */ |
346 | 39 | if (Z_OBJ_P(fast_call)) { |
347 | 16 | OBJ_RELEASE(Z_OBJ_P(fast_call)); |
348 | 16 | } |
349 | 39 | } |
350 | | |
351 | 39 | try_catch_offset--; |
352 | 39 | } |
353 | | |
354 | 180 | zend_generator_close(generator, 0); |
355 | 180 | } |
356 | | /* }}} */ |
357 | | |
358 | | static void zend_generator_free_storage(zend_object *object) /* {{{ */ |
359 | 4.95k | { |
360 | 4.95k | zend_generator *generator = (zend_generator*) object; |
361 | | |
362 | 4.95k | zend_generator_close(generator, 0); |
363 | | |
364 | 4.95k | if (generator->func && (generator->func->common.fn_flags & ZEND_ACC_CLOSURE)) { |
365 | 452 | OBJ_RELEASE(ZEND_CLOSURE_OBJECT(generator->func)); |
366 | 452 | } |
367 | | |
368 | | /* we can't immediately free them in zend_generator_close() else yield from won't be able to fetch it */ |
369 | 4.95k | zval_ptr_dtor(&generator->value); |
370 | 4.95k | zval_ptr_dtor(&generator->key); |
371 | | |
372 | 4.95k | if (EXPECTED(!Z_ISUNDEF(generator->retval))) { |
373 | 1.43k | zval_ptr_dtor(&generator->retval); |
374 | 1.43k | } |
375 | | |
376 | 4.95k | if (UNEXPECTED(generator->node.children > 1)) { |
377 | 0 | zend_hash_destroy(generator->node.child.ht); |
378 | 0 | efree(generator->node.child.ht); |
379 | 0 | } |
380 | | |
381 | 4.95k | zend_object_std_dtor(&generator->std); |
382 | 4.95k | } |
383 | | /* }}} */ |
384 | | |
385 | | HashTable *zend_generator_frame_gc(zend_get_gc_buffer *gc_buffer, zend_generator *generator) |
386 | 2.19k | { |
387 | 2.19k | zend_execute_data *execute_data = generator->execute_data; |
388 | 2.19k | zend_execute_data *call = NULL; |
389 | | |
390 | 2.19k | zend_get_gc_buffer_add_zval(gc_buffer, &generator->value); |
391 | 2.19k | zend_get_gc_buffer_add_zval(gc_buffer, &generator->key); |
392 | 2.19k | zend_get_gc_buffer_add_zval(gc_buffer, &generator->retval); |
393 | 2.19k | zend_get_gc_buffer_add_zval(gc_buffer, &generator->values); |
394 | | |
395 | 2.19k | if (UNEXPECTED(generator->frozen_call_stack)) { |
396 | | /* The frozen stack is linked in reverse order */ |
397 | 286 | call = zend_generator_revert_call_stack(generator->frozen_call_stack); |
398 | 286 | } |
399 | | |
400 | 2.19k | HashTable *ht = zend_unfinished_execution_gc_ex(execute_data, call, gc_buffer, true); |
401 | | |
402 | 2.19k | if (UNEXPECTED(generator->frozen_call_stack)) { |
403 | 286 | zend_generator_revert_call_stack(call); |
404 | 286 | } |
405 | | |
406 | 2.19k | if (generator->node.parent) { |
407 | 768 | zend_get_gc_buffer_add_obj(gc_buffer, &generator->node.parent->std); |
408 | 768 | } |
409 | | |
410 | 2.19k | return ht; |
411 | 2.19k | } |
412 | | |
413 | | static HashTable *zend_generator_get_gc(zend_object *object, zval **table, int *n) /* {{{ */ |
414 | 3.64k | { |
415 | 3.64k | zend_generator *generator = (zend_generator*)object; |
416 | 3.64k | zend_execute_data *execute_data = generator->execute_data; |
417 | | |
418 | 3.64k | if (!execute_data) { |
419 | 1.44k | if (UNEXPECTED(generator->func->common.fn_flags & ZEND_ACC_CLOSURE)) { |
420 | 389 | zend_get_gc_buffer *gc_buffer = zend_get_gc_buffer_create(); |
421 | 389 | zend_get_gc_buffer_add_zval(gc_buffer, &generator->value); |
422 | 389 | zend_get_gc_buffer_add_zval(gc_buffer, &generator->key); |
423 | 389 | zend_get_gc_buffer_add_zval(gc_buffer, &generator->retval); |
424 | 389 | zend_get_gc_buffer_add_obj(gc_buffer, ZEND_CLOSURE_OBJECT(generator->func)); |
425 | 389 | zend_get_gc_buffer_use(gc_buffer, table, n); |
426 | 1.05k | } else { |
427 | | /* If the non-closure generator has been closed, it can only hold on to three values: The value, key |
428 | | * and retval. These three zvals are stored sequentially starting at &generator->value. */ |
429 | 1.05k | *table = &generator->value; |
430 | 1.05k | *n = 3; |
431 | 1.05k | } |
432 | 1.44k | return NULL; |
433 | 1.44k | } |
434 | | |
435 | 2.19k | if (generator->flags & ZEND_GENERATOR_CURRENTLY_RUNNING) { |
436 | | /* If the generator is currently running, we certainly won't be able to GC any values it |
437 | | * holds on to. The execute_data state might be inconsistent during execution (e.g. because |
438 | | * GC has been triggered in the middle of a variable reassignment), so we should not try |
439 | | * to inspect it here. */ |
440 | 245 | *table = NULL; |
441 | 245 | *n = 0; |
442 | 245 | return NULL; |
443 | 245 | } |
444 | | |
445 | 1.95k | zend_get_gc_buffer *gc_buffer = zend_get_gc_buffer_create(); |
446 | 1.95k | HashTable *ht = zend_generator_frame_gc(gc_buffer, generator); |
447 | 1.95k | zend_get_gc_buffer_use(gc_buffer, table, n); |
448 | | |
449 | 1.95k | return ht; |
450 | 2.19k | } |
451 | | /* }}} */ |
452 | | |
453 | | static zend_object *zend_generator_create(zend_class_entry *class_type) /* {{{ */ |
454 | 4.95k | { |
455 | 4.95k | zend_generator *generator = emalloc(sizeof(zend_generator)); |
456 | 4.95k | memset(generator, 0, sizeof(zend_generator)); |
457 | | |
458 | | /* The key will be incremented on first use, so it'll start at 0 */ |
459 | 4.95k | generator->largest_used_integer_key = -1; |
460 | | |
461 | 4.95k | ZVAL_UNDEF(&generator->retval); |
462 | 4.95k | ZVAL_UNDEF(&generator->values); |
463 | | |
464 | | /* By default we have a tree of only one node */ |
465 | 4.95k | generator->node.parent = NULL; |
466 | 4.95k | generator->node.children = 0; |
467 | 4.95k | generator->node.ptr.root = NULL; |
468 | | |
469 | 4.95k | zend_object_std_init(&generator->std, class_type); |
470 | 4.95k | return (zend_object*)generator; |
471 | 4.95k | } |
472 | | /* }}} */ |
473 | | |
474 | | static ZEND_COLD zend_function *zend_generator_get_constructor(zend_object *object) /* {{{ */ |
475 | 10 | { |
476 | 10 | zend_throw_error(NULL, "The \"Generator\" class is reserved for internal use and cannot be manually instantiated"); |
477 | | |
478 | 10 | return NULL; |
479 | 10 | } |
480 | | /* }}} */ |
481 | | |
482 | | ZEND_API zend_execute_data *zend_generator_check_placeholder_frame(zend_execute_data *ptr) |
483 | 474 | { |
484 | 474 | if (!ptr->func && Z_TYPE(ptr->This) == IS_OBJECT) { |
485 | 63 | if (Z_OBJCE(ptr->This) == zend_ce_generator) { |
486 | 63 | zend_generator *generator = (zend_generator *) Z_OBJ(ptr->This); |
487 | 63 | zend_execute_data *prev = ptr->prev_execute_data; |
488 | 63 | ZEND_ASSERT(generator->node.parent && "Placeholder only used with delegation"); |
489 | 81 | while (generator->node.parent->node.parent) { |
490 | 18 | generator->execute_data->prev_execute_data = prev; |
491 | 18 | prev = generator->execute_data; |
492 | 18 | generator = generator->node.parent; |
493 | 18 | } |
494 | 63 | generator->execute_data->prev_execute_data = prev; |
495 | 63 | ptr = generator->execute_data; |
496 | 63 | } |
497 | 63 | } |
498 | 474 | return ptr; |
499 | 474 | } |
500 | | |
501 | | static void zend_generator_throw_exception(zend_generator *generator, zval *exception) |
502 | 230 | { |
503 | 230 | zend_execute_data *original_execute_data = EG(current_execute_data); |
504 | | |
505 | | /* Throw the exception in the context of the generator. Decrementing the opline |
506 | | * to pretend the exception happened during the YIELD opcode. */ |
507 | 230 | EG(current_execute_data) = generator->execute_data; |
508 | 230 | generator->execute_data->prev_execute_data = original_execute_data; |
509 | | |
510 | 230 | if (exception) { |
511 | 80 | zend_throw_exception_object(exception); |
512 | 150 | } else { |
513 | 150 | zend_rethrow_exception(EG(current_execute_data)); |
514 | 150 | } |
515 | | |
516 | | /* if we don't stop an array/iterator yield from, the exception will only reach the generator after the values were all iterated over */ |
517 | 230 | if (UNEXPECTED(Z_TYPE(generator->values) != IS_UNDEF)) { |
518 | 18 | zval_ptr_dtor(&generator->values); |
519 | 18 | ZVAL_UNDEF(&generator->values); |
520 | 18 | } |
521 | | |
522 | 230 | EG(current_execute_data) = original_execute_data; |
523 | 230 | } |
524 | | |
525 | | static void zend_generator_add_child(zend_generator *generator, zend_generator *child) |
526 | 1.25k | { |
527 | 1.25k | zend_generator_node *node = &generator->node; |
528 | | |
529 | 1.25k | if (node->children == 0) { |
530 | 1.12k | node->child.single = child; |
531 | 1.12k | } else { |
532 | 134 | if (node->children == 1) { |
533 | 134 | HashTable *ht = emalloc(sizeof(HashTable)); |
534 | 134 | zend_hash_init(ht, 0, NULL, NULL, 0); |
535 | 134 | zend_hash_index_add_new_ptr(ht, |
536 | 134 | (zend_ulong) node->child.single, node->child.single); |
537 | 134 | node->child.ht = ht; |
538 | 134 | } |
539 | | |
540 | 134 | zend_hash_index_add_new_ptr(node->child.ht, (zend_ulong) child, child); |
541 | 134 | } |
542 | | |
543 | 1.25k | ++node->children; |
544 | 1.25k | } |
545 | | |
546 | | void zend_generator_yield_from(zend_generator *generator, zend_generator *from) |
547 | 1.25k | { |
548 | 1.25k | ZEND_ASSERT(!generator->node.parent && "Already has parent?"); |
549 | 1.25k | zend_generator *leaf = clear_link_to_leaf(generator); |
550 | 1.25k | if (leaf && !from->node.parent && !from->node.ptr.leaf) { |
551 | 727 | from->node.ptr.leaf = leaf; |
552 | 727 | leaf->node.ptr.root = from; |
553 | 727 | } |
554 | 1.25k | generator->node.parent = from; |
555 | 1.25k | zend_generator_add_child(from, generator); |
556 | 1.25k | generator->flags |= ZEND_GENERATOR_DO_INIT; |
557 | 1.25k | } |
558 | | |
559 | | ZEND_API zend_generator *zend_generator_update_root(zend_generator *generator) |
560 | 1.59k | { |
561 | 1.59k | zend_generator *root = generator->node.parent; |
562 | 26.9k | while (root->node.parent) { |
563 | 25.3k | root = root->node.parent; |
564 | 25.3k | } |
565 | | |
566 | 1.59k | clear_link_to_leaf(root); |
567 | 1.59k | root->node.ptr.leaf = generator; |
568 | 1.59k | generator->node.ptr.root = root; |
569 | 1.59k | return root; |
570 | 1.59k | } |
571 | | |
572 | | static zend_generator *get_new_root(zend_generator *generator, zend_generator *root) |
573 | 605 | { |
574 | 1.10k | while (!root->execute_data && root->node.children == 1) { |
575 | 499 | root = root->node.child.single; |
576 | 499 | } |
577 | | |
578 | 605 | if (root->execute_data) { |
579 | 499 | return root; |
580 | 499 | } |
581 | | |
582 | | /* We have reached a multi-child node haven't found the root yet. We don't know which |
583 | | * child to follow, so perform the search from the other direction instead. */ |
584 | 144 | while (generator->node.parent->execute_data) { |
585 | 38 | generator = generator->node.parent; |
586 | 38 | } |
587 | | |
588 | 106 | return generator; |
589 | 605 | } |
590 | | |
591 | | ZEND_API zend_generator *zend_generator_update_current(zend_generator *generator) |
592 | 605 | { |
593 | 605 | zend_generator *old_root = generator->node.ptr.root; |
594 | 605 | ZEND_ASSERT(!old_root->execute_data && "Nothing to update?"); |
595 | | |
596 | 605 | zend_generator *new_root = get_new_root(generator, old_root); |
597 | | |
598 | 605 | ZEND_ASSERT(old_root->node.ptr.leaf == generator); |
599 | 605 | generator->node.ptr.root = new_root; |
600 | 605 | new_root->node.ptr.leaf = generator; |
601 | 605 | old_root->node.ptr.leaf = NULL; |
602 | | |
603 | 605 | zend_generator *new_root_parent = new_root->node.parent; |
604 | 605 | ZEND_ASSERT(new_root_parent); |
605 | 605 | zend_generator_remove_child(&new_root_parent->node, new_root); |
606 | | |
607 | 605 | if (EXPECTED(EG(exception) == NULL) && EXPECTED((OBJ_FLAGS(&generator->std) & IS_OBJ_DESTRUCTOR_CALLED) == 0)) { |
608 | 302 | zend_op *yield_from = (zend_op *) new_root->execute_data->opline; |
609 | | |
610 | 302 | if (yield_from->opcode == ZEND_YIELD_FROM) { |
611 | 302 | if (Z_ISUNDEF(new_root_parent->retval)) { |
612 | | /* Throw the exception in the context of the generator */ |
613 | 15 | zend_execute_data *original_execute_data = EG(current_execute_data); |
614 | 15 | EG(current_execute_data) = new_root->execute_data; |
615 | | |
616 | 15 | if (new_root == generator) { |
617 | 15 | new_root->execute_data->prev_execute_data = original_execute_data; |
618 | 15 | } else { |
619 | 0 | new_root->execute_data->prev_execute_data = &generator->execute_fake; |
620 | 0 | generator->execute_fake.prev_execute_data = original_execute_data; |
621 | 0 | } |
622 | | |
623 | 15 | zend_throw_exception(zend_ce_ClosedGeneratorException, "Generator yielded from aborted, no return value available", 0); |
624 | | |
625 | 15 | EG(current_execute_data) = original_execute_data; |
626 | | |
627 | 15 | if (!(old_root->flags & ZEND_GENERATOR_CURRENTLY_RUNNING)) { |
628 | 15 | new_root->node.parent = NULL; |
629 | 15 | OBJ_RELEASE(&new_root_parent->std); |
630 | 15 | zend_generator_resume(generator); |
631 | 15 | return zend_generator_get_current(generator); |
632 | 15 | } |
633 | 287 | } else { |
634 | 287 | zval_ptr_dtor(&new_root->value); |
635 | 287 | ZVAL_COPY(&new_root->value, &new_root_parent->value); |
636 | 287 | ZVAL_COPY(ZEND_CALL_VAR(new_root->execute_data, yield_from->result.var), &new_root_parent->retval); |
637 | 287 | } |
638 | 302 | } |
639 | 302 | } |
640 | | |
641 | 590 | new_root->node.parent = NULL; |
642 | 590 | OBJ_RELEASE(&new_root_parent->std); |
643 | | |
644 | 590 | return new_root; |
645 | 605 | } |
646 | | |
647 | | static zend_result zend_generator_get_next_delegated_value(zend_generator *generator) /* {{{ */ |
648 | 308 | { |
649 | 308 | zval *value; |
650 | 308 | if (Z_TYPE(generator->values) == IS_ARRAY) { |
651 | 158 | HashTable *ht = Z_ARR(generator->values); |
652 | 158 | HashPosition pos = Z_FE_POS(generator->values); |
653 | | |
654 | 158 | if (HT_IS_PACKED(ht)) { |
655 | 158 | do { |
656 | 158 | if (UNEXPECTED(pos >= ht->nNumUsed)) { |
657 | | /* Reached end of array */ |
658 | 24 | goto failure; |
659 | 24 | } |
660 | | |
661 | 134 | value = &ht->arPacked[pos]; |
662 | 134 | pos++; |
663 | 158 | } while (Z_ISUNDEF_P(value)); |
664 | | |
665 | 134 | zval_ptr_dtor(&generator->value); |
666 | 134 | ZVAL_COPY(&generator->value, value); |
667 | | |
668 | 134 | zval_ptr_dtor(&generator->key); |
669 | 134 | ZVAL_LONG(&generator->key, pos - 1); |
670 | 134 | } else { |
671 | 0 | Bucket *p; |
672 | |
|
673 | 0 | do { |
674 | 0 | if (UNEXPECTED(pos >= ht->nNumUsed)) { |
675 | | /* Reached end of array */ |
676 | 0 | goto failure; |
677 | 0 | } |
678 | | |
679 | 0 | p = &ht->arData[pos]; |
680 | 0 | value = &p->val; |
681 | 0 | pos++; |
682 | 0 | } while (Z_ISUNDEF_P(value)); |
683 | | |
684 | 0 | zval_ptr_dtor(&generator->value); |
685 | 0 | ZVAL_COPY(&generator->value, value); |
686 | |
|
687 | 0 | zval_ptr_dtor(&generator->key); |
688 | 0 | if (p->key) { |
689 | 0 | ZVAL_STR_COPY(&generator->key, p->key); |
690 | 0 | } else { |
691 | 0 | ZVAL_LONG(&generator->key, p->h); |
692 | 0 | } |
693 | 0 | } |
694 | 134 | Z_FE_POS(generator->values) = pos; |
695 | 150 | } else { |
696 | 150 | zend_object_iterator *iter = (zend_object_iterator *) Z_OBJ(generator->values); |
697 | | |
698 | 150 | if (iter->index++ > 0) { |
699 | 73 | iter->funcs->move_forward(iter); |
700 | 73 | if (UNEXPECTED(EG(exception) != NULL)) { |
701 | 48 | goto failure; |
702 | 48 | } |
703 | 73 | } |
704 | | |
705 | 102 | if (iter->funcs->valid(iter) == FAILURE) { |
706 | | /* reached end of iteration */ |
707 | 12 | goto failure; |
708 | 12 | } |
709 | | |
710 | 90 | value = iter->funcs->get_current_data(iter); |
711 | 90 | if (UNEXPECTED(EG(exception) != NULL) || UNEXPECTED(!value)) { |
712 | 5 | goto failure; |
713 | 5 | } |
714 | | |
715 | 85 | zval_ptr_dtor(&generator->value); |
716 | 85 | ZVAL_COPY(&generator->value, value); |
717 | | |
718 | 85 | zval_ptr_dtor(&generator->key); |
719 | 85 | if (iter->funcs->get_current_key) { |
720 | 85 | iter->funcs->get_current_key(iter, &generator->key); |
721 | 85 | if (UNEXPECTED(EG(exception) != NULL)) { |
722 | 7 | ZVAL_UNDEF(&generator->key); |
723 | 7 | goto failure; |
724 | 7 | } |
725 | 85 | } else { |
726 | 0 | ZVAL_LONG(&generator->key, iter->index); |
727 | 0 | } |
728 | 85 | } |
729 | | |
730 | 212 | return SUCCESS; |
731 | | |
732 | 96 | failure: |
733 | 96 | zval_ptr_dtor(&generator->values); |
734 | 96 | ZVAL_UNDEF(&generator->values); |
735 | | |
736 | 96 | return FAILURE; |
737 | 308 | } |
738 | | /* }}} */ |
739 | | |
740 | | ZEND_API void zend_generator_resume(zend_generator *orig_generator) /* {{{ */ |
741 | 6.19k | { |
742 | 6.19k | zend_generator *generator = zend_generator_get_current(orig_generator); |
743 | | |
744 | | /* The generator is already closed, thus can't resume */ |
745 | 6.19k | if (UNEXPECTED(!generator->execute_data)) { |
746 | 158 | return; |
747 | 158 | } |
748 | | |
749 | 7.86k | try_again: |
750 | 7.86k | if (generator->flags & ZEND_GENERATOR_CURRENTLY_RUNNING) { |
751 | 24 | zend_throw_error(NULL, "Cannot resume an already running generator"); |
752 | 24 | return; |
753 | 24 | } |
754 | | |
755 | 7.84k | if (UNEXPECTED((orig_generator->flags & ZEND_GENERATOR_DO_INIT) != 0 && !Z_ISUNDEF(generator->value))) { |
756 | | /* We must not advance Generator if we yield from a Generator being currently run */ |
757 | 256 | orig_generator->flags &= ~ZEND_GENERATOR_DO_INIT; |
758 | 256 | return; |
759 | 256 | } |
760 | | |
761 | 7.58k | if (EG(active_fiber)) { |
762 | 331 | orig_generator->flags |= ZEND_GENERATOR_IN_FIBER; |
763 | 331 | generator->flags |= ZEND_GENERATOR_IN_FIBER; |
764 | 331 | } |
765 | | |
766 | | /* Drop the AT_FIRST_YIELD flag */ |
767 | 7.58k | orig_generator->flags &= ~ZEND_GENERATOR_AT_FIRST_YIELD; |
768 | | |
769 | | /* Backup executor globals */ |
770 | 7.58k | zend_execute_data *original_execute_data = EG(current_execute_data); |
771 | 7.58k | uint32_t original_jit_trace_num = EG(jit_trace_num); |
772 | | |
773 | | /* Set executor globals */ |
774 | 7.58k | EG(current_execute_data) = generator->execute_data; |
775 | 7.58k | EG(jit_trace_num) = 0; |
776 | | |
777 | | /* We want the backtrace to look as if the generator function was |
778 | | * called from whatever method we are current running (e.g. next()). |
779 | | * So we have to link generator call frame with caller call frame. */ |
780 | 7.58k | if (generator == orig_generator) { |
781 | 5.58k | generator->execute_data->prev_execute_data = original_execute_data; |
782 | 5.58k | } else { |
783 | | /* We need some execute_data placeholder in stacktrace to be replaced |
784 | | * by the real stack trace when needed */ |
785 | 1.99k | generator->execute_data->prev_execute_data = &orig_generator->execute_fake; |
786 | 1.99k | orig_generator->execute_fake.prev_execute_data = original_execute_data; |
787 | 1.99k | } |
788 | | |
789 | | /* Ensure this is run after executor_data swap to have a proper stack trace */ |
790 | 7.58k | if (UNEXPECTED(!Z_ISUNDEF(generator->values))) { |
791 | 308 | if (EXPECTED(zend_generator_get_next_delegated_value(generator) == SUCCESS)) { |
792 | | /* Restore executor globals */ |
793 | 212 | EG(current_execute_data) = original_execute_data; |
794 | 212 | EG(jit_trace_num) = original_jit_trace_num; |
795 | | |
796 | 212 | orig_generator->flags &= ~(ZEND_GENERATOR_DO_INIT | ZEND_GENERATOR_IN_FIBER); |
797 | 212 | generator->flags &= ~ZEND_GENERATOR_IN_FIBER; |
798 | 212 | return; |
799 | 212 | } |
800 | | /* If there are no more delegated values, resume the generator |
801 | | * after the "yield from" expression. */ |
802 | 308 | } |
803 | | |
804 | 7.37k | if (UNEXPECTED(generator->frozen_call_stack)) { |
805 | | /* Restore frozen call-stack */ |
806 | 206 | zend_generator_restore_call_stack(generator); |
807 | 206 | } |
808 | | |
809 | | /* Resume execution */ |
810 | 7.37k | ZEND_ASSERT(generator->execute_data->opline->opcode == ZEND_GENERATOR_CREATE |
811 | 7.37k | || generator->execute_data->opline->opcode == ZEND_YIELD |
812 | 7.37k | || generator->execute_data->opline->opcode == ZEND_YIELD_FROM |
813 | | /* opline points to EG(exception_op), which is a sequence of |
814 | | * ZEND_HANDLE_EXCEPTION ops, so the following increment is safe */ |
815 | 7.37k | || generator->execute_data->opline->opcode == ZEND_HANDLE_EXCEPTION |
816 | | /* opline points to the start of a finally block minus one op to |
817 | | * account for the following increment */ |
818 | 7.37k | || (generator->flags & ZEND_GENERATOR_FORCED_CLOSE)); |
819 | 7.37k | generator->execute_data->opline++; |
820 | 7.37k | generator->flags |= ZEND_GENERATOR_CURRENTLY_RUNNING; |
821 | 7.37k | if (!ZEND_OBSERVER_ENABLED) { |
822 | 7.37k | zend_execute_ex(generator->execute_data); |
823 | 7.37k | } else { |
824 | 0 | zend_observer_generator_resume(generator->execute_data); |
825 | 0 | zend_execute_ex(generator->execute_data); |
826 | 0 | if (generator->execute_data) { |
827 | | /* On the final return, this will be called from ZEND_GENERATOR_RETURN */ |
828 | 0 | zend_observer_fcall_end(generator->execute_data, &generator->value); |
829 | 0 | } |
830 | 0 | } |
831 | 7.37k | generator->flags &= ~(ZEND_GENERATOR_CURRENTLY_RUNNING | ZEND_GENERATOR_IN_FIBER); |
832 | | |
833 | 7.37k | generator->frozen_call_stack = NULL; |
834 | 7.37k | if (EXPECTED(generator->execute_data) && |
835 | 7.37k | UNEXPECTED(generator->execute_data->call)) { |
836 | | /* Frize call-stack */ |
837 | 303 | generator->frozen_call_stack = zend_generator_freeze_call_stack(generator->execute_data); |
838 | 303 | } |
839 | | |
840 | | /* Restore executor globals */ |
841 | 7.37k | EG(current_execute_data) = original_execute_data; |
842 | 7.37k | EG(jit_trace_num) = original_jit_trace_num; |
843 | | |
844 | | /* If an exception was thrown in the generator we have to internally |
845 | | * rethrow it in the parent scope. |
846 | | * In case we did yield from, the Exception must be rethrown into |
847 | | * its calling frame (see above in if (check_yield_from). */ |
848 | 7.37k | if (UNEXPECTED(EG(exception) != NULL)) { |
849 | 607 | if (generator == orig_generator) { |
850 | 457 | zend_generator_close(generator, 0); |
851 | 457 | if (!EG(current_execute_data)) { |
852 | 10 | zend_throw_exception_internal(NULL); |
853 | 447 | } else if (EG(current_execute_data)->func && |
854 | 447 | ZEND_USER_CODE(EG(current_execute_data)->func->common.type)) { |
855 | 136 | zend_rethrow_exception(EG(current_execute_data)); |
856 | 136 | } |
857 | 457 | } else { |
858 | 150 | generator = zend_generator_get_current(orig_generator); |
859 | 150 | zend_generator_throw_exception(generator, NULL); |
860 | 150 | orig_generator->flags &= ~ZEND_GENERATOR_DO_INIT; |
861 | 150 | goto try_again; |
862 | 150 | } |
863 | 607 | } |
864 | | |
865 | | /* yield from was used, try another resume. */ |
866 | 7.22k | if (UNEXPECTED((generator != orig_generator && !Z_ISUNDEF(generator->retval)) || (generator->execute_data && generator->execute_data->opline->opcode == ZEND_YIELD_FROM))) { |
867 | 1.68k | generator = zend_generator_get_current(orig_generator); |
868 | 1.68k | goto try_again; |
869 | 1.68k | } |
870 | | |
871 | 5.54k | orig_generator->flags &= ~(ZEND_GENERATOR_DO_INIT | ZEND_GENERATOR_IN_FIBER); |
872 | 5.54k | } |
873 | | /* }}} */ |
874 | | |
875 | | static inline void zend_generator_ensure_initialized(zend_generator *generator) /* {{{ */ |
876 | 14.0k | { |
877 | 14.0k | if (UNEXPECTED(Z_TYPE(generator->value) == IS_UNDEF) && EXPECTED(generator->execute_data) && EXPECTED(generator->node.parent == NULL)) { |
878 | 2.32k | zend_generator_resume(generator); |
879 | 2.32k | generator->flags |= ZEND_GENERATOR_AT_FIRST_YIELD; |
880 | 2.32k | } |
881 | 14.0k | } |
882 | | /* }}} */ |
883 | | |
884 | | static inline void zend_generator_rewind(zend_generator *generator) /* {{{ */ |
885 | 1.31k | { |
886 | 1.31k | zend_generator_ensure_initialized(generator); |
887 | | |
888 | 1.31k | if (!(generator->flags & ZEND_GENERATOR_AT_FIRST_YIELD)) { |
889 | 15 | zend_throw_exception(NULL, "Cannot rewind a generator that was already run", 0); |
890 | 15 | } |
891 | 1.31k | } |
892 | | /* }}} */ |
893 | | |
894 | | /* {{{ Rewind the generator */ |
895 | | ZEND_METHOD(Generator, rewind) |
896 | 210 | { |
897 | 210 | zend_generator *generator; |
898 | | |
899 | 210 | ZEND_PARSE_PARAMETERS_NONE(); |
900 | | |
901 | 208 | generator = (zend_generator *) Z_OBJ_P(ZEND_THIS); |
902 | | |
903 | 208 | zend_generator_rewind(generator); |
904 | 208 | } |
905 | | /* }}} */ |
906 | | |
907 | | /* {{{ Check whether the generator is valid */ |
908 | | ZEND_METHOD(Generator, valid) |
909 | 1.15k | { |
910 | 1.15k | zend_generator *generator; |
911 | | |
912 | 1.15k | ZEND_PARSE_PARAMETERS_NONE(); |
913 | | |
914 | 1.15k | generator = (zend_generator *) Z_OBJ_P(ZEND_THIS); |
915 | | |
916 | 1.15k | zend_generator_ensure_initialized(generator); |
917 | | |
918 | 1.15k | zend_generator_get_current(generator); |
919 | | |
920 | 1.15k | RETURN_BOOL(EXPECTED(generator->execute_data != NULL)); |
921 | 1.15k | } |
922 | | /* }}} */ |
923 | | |
924 | | /* {{{ Get the current value */ |
925 | | ZEND_METHOD(Generator, current) |
926 | 1.49k | { |
927 | 1.49k | zend_generator *generator, *root; |
928 | | |
929 | 1.49k | ZEND_PARSE_PARAMETERS_NONE(); |
930 | | |
931 | 1.49k | generator = (zend_generator *) Z_OBJ_P(ZEND_THIS); |
932 | | |
933 | 1.49k | zend_generator_ensure_initialized(generator); |
934 | | |
935 | 1.49k | root = zend_generator_get_current(generator); |
936 | 1.49k | if (EXPECTED(generator->execute_data != NULL && Z_TYPE(root->value) != IS_UNDEF)) { |
937 | 1.27k | RETURN_COPY_DEREF(&root->value); |
938 | 1.27k | } |
939 | 1.49k | } |
940 | | /* }}} */ |
941 | | |
942 | | /* {{{ Get the current key */ |
943 | | ZEND_METHOD(Generator, key) |
944 | 205 | { |
945 | 205 | zend_generator *generator, *root; |
946 | | |
947 | 205 | ZEND_PARSE_PARAMETERS_NONE(); |
948 | | |
949 | 205 | generator = (zend_generator *) Z_OBJ_P(ZEND_THIS); |
950 | | |
951 | 205 | zend_generator_ensure_initialized(generator); |
952 | | |
953 | 205 | root = zend_generator_get_current(generator); |
954 | 205 | if (EXPECTED(generator->execute_data != NULL && Z_TYPE(root->key) != IS_UNDEF)) { |
955 | 205 | RETURN_COPY_DEREF(&root->key); |
956 | 205 | } |
957 | 205 | } |
958 | | /* }}} */ |
959 | | |
960 | | /* {{{ Advances the generator */ |
961 | | ZEND_METHOD(Generator, next) |
962 | 1.10k | { |
963 | 1.10k | zend_generator *generator; |
964 | | |
965 | 1.10k | ZEND_PARSE_PARAMETERS_NONE(); |
966 | | |
967 | 1.10k | generator = (zend_generator *) Z_OBJ_P(ZEND_THIS); |
968 | | |
969 | 1.10k | zend_generator_ensure_initialized(generator); |
970 | | |
971 | 1.10k | zend_generator_resume(generator); |
972 | 1.10k | } |
973 | | /* }}} */ |
974 | | |
975 | | /* {{{ Sends a value to the generator */ |
976 | | ZEND_METHOD(Generator, send) |
977 | 393 | { |
978 | 393 | zval *value; |
979 | 393 | zend_generator *generator, *root; |
980 | | |
981 | 1.17k | ZEND_PARSE_PARAMETERS_START(1, 1) |
982 | 1.57k | Z_PARAM_ZVAL(value) |
983 | 1.57k | ZEND_PARSE_PARAMETERS_END(); |
984 | | |
985 | 393 | generator = (zend_generator *) Z_OBJ_P(ZEND_THIS); |
986 | | |
987 | 393 | zend_generator_ensure_initialized(generator); |
988 | | |
989 | | /* The generator is already closed, thus can't send anything */ |
990 | 393 | if (UNEXPECTED(!generator->execute_data)) { |
991 | 8 | return; |
992 | 8 | } |
993 | | |
994 | 385 | root = zend_generator_get_current(generator); |
995 | | /* Put sent value in the target VAR slot, if it is used */ |
996 | 385 | if (root->send_target && !(root->flags & ZEND_GENERATOR_CURRENTLY_RUNNING)) { |
997 | 305 | ZVAL_COPY(root->send_target, value); |
998 | 305 | } |
999 | | |
1000 | 385 | zend_generator_resume(generator); |
1001 | | |
1002 | 385 | root = zend_generator_get_current(generator); |
1003 | 385 | if (EXPECTED(generator->execute_data)) { |
1004 | 283 | RETURN_COPY_DEREF(&root->value); |
1005 | 283 | } |
1006 | 385 | } |
1007 | | /* }}} */ |
1008 | | |
1009 | | /* {{{ Throws an exception into the generator */ |
1010 | | ZEND_METHOD(Generator, throw) |
1011 | 92 | { |
1012 | 92 | zval *exception; |
1013 | 92 | zend_generator *generator; |
1014 | | |
1015 | 276 | ZEND_PARSE_PARAMETERS_START(1, 1) |
1016 | 368 | Z_PARAM_OBJECT_OF_CLASS(exception, zend_ce_throwable); |
1017 | 92 | ZEND_PARSE_PARAMETERS_END(); |
1018 | | |
1019 | 87 | Z_TRY_ADDREF_P(exception); |
1020 | | |
1021 | 87 | generator = (zend_generator *) Z_OBJ_P(ZEND_THIS); |
1022 | | |
1023 | 87 | zend_generator_ensure_initialized(generator); |
1024 | | |
1025 | 87 | if (generator->execute_data) { |
1026 | 80 | zend_generator *root = zend_generator_get_current(generator); |
1027 | | |
1028 | 80 | zend_generator_throw_exception(root, exception); |
1029 | | |
1030 | 80 | zend_generator_resume(generator); |
1031 | | |
1032 | 80 | root = zend_generator_get_current(generator); |
1033 | 80 | if (generator->execute_data) { |
1034 | 34 | RETURN_COPY_DEREF(&root->value); |
1035 | 34 | } |
1036 | 80 | } else { |
1037 | | /* If the generator is already closed throw the exception in the |
1038 | | * current context */ |
1039 | 7 | zend_throw_exception_object(exception); |
1040 | 7 | } |
1041 | 87 | } |
1042 | | /* }}} */ |
1043 | | |
1044 | | /* {{{ Retrieves the return value of the generator */ |
1045 | | ZEND_METHOD(Generator, getReturn) |
1046 | 102 | { |
1047 | 102 | zend_generator *generator; |
1048 | | |
1049 | 102 | ZEND_PARSE_PARAMETERS_NONE(); |
1050 | | |
1051 | 102 | generator = (zend_generator *) Z_OBJ_P(ZEND_THIS); |
1052 | | |
1053 | 102 | zend_generator_ensure_initialized(generator); |
1054 | 102 | if (UNEXPECTED(EG(exception))) { |
1055 | 10 | return; |
1056 | 10 | } |
1057 | | |
1058 | 92 | if (Z_ISUNDEF(generator->retval)) { |
1059 | | /* Generator hasn't returned yet -> error! */ |
1060 | 20 | zend_throw_exception(NULL, |
1061 | 20 | "Cannot get return value of a generator that hasn't returned", 0); |
1062 | 20 | return; |
1063 | 20 | } |
1064 | | |
1065 | 72 | ZVAL_COPY(return_value, &generator->retval); |
1066 | 72 | } |
1067 | | /* }}} */ |
1068 | | |
1069 | | ZEND_METHOD(Generator, __debugInfo) |
1070 | 167 | { |
1071 | 167 | zend_generator *generator; |
1072 | | |
1073 | 167 | ZEND_PARSE_PARAMETERS_NONE(); |
1074 | | |
1075 | 167 | generator = (zend_generator *) Z_OBJ_P(ZEND_THIS); |
1076 | | |
1077 | 167 | array_init(return_value); |
1078 | | |
1079 | 167 | zend_function *func = generator->func; |
1080 | | |
1081 | 167 | zval val; |
1082 | 167 | if (func->common.scope) { |
1083 | 27 | zend_string *class_name = func->common.scope->name; |
1084 | 27 | zend_string *func_name = func->common.function_name; |
1085 | 27 | zend_string *combined = zend_string_concat3( |
1086 | 27 | ZSTR_VAL(class_name), ZSTR_LEN(class_name), |
1087 | 27 | "::", strlen("::"), |
1088 | 27 | ZSTR_VAL(func_name), ZSTR_LEN(func_name) |
1089 | 27 | ); |
1090 | 27 | ZVAL_NEW_STR(&val, combined); |
1091 | 140 | } else { |
1092 | 140 | ZVAL_STR_COPY(&val, func->common.function_name); |
1093 | 140 | } |
1094 | | |
1095 | 167 | zend_hash_update(Z_ARR_P(return_value), ZSTR_KNOWN(ZEND_STR_FUNCTION), &val); |
1096 | 167 | } |
1097 | | |
1098 | | /* get_iterator implementation */ |
1099 | | |
1100 | | static void zend_generator_iterator_dtor(zend_object_iterator *iterator) /* {{{ */ |
1101 | 1.11k | { |
1102 | 1.11k | zval_ptr_dtor(&iterator->data); |
1103 | 1.11k | } |
1104 | | /* }}} */ |
1105 | | |
1106 | | static zend_result zend_generator_iterator_valid(zend_object_iterator *iterator) /* {{{ */ |
1107 | 3.12k | { |
1108 | 3.12k | zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data); |
1109 | | |
1110 | 3.12k | zend_generator_ensure_initialized(generator); |
1111 | | |
1112 | 3.12k | zend_generator_get_current(generator); |
1113 | | |
1114 | 3.12k | return generator->execute_data ? SUCCESS : FAILURE; |
1115 | 3.12k | } |
1116 | | /* }}} */ |
1117 | | |
1118 | | static zval *zend_generator_iterator_get_data(zend_object_iterator *iterator) /* {{{ */ |
1119 | 2.32k | { |
1120 | 2.32k | zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data), *root; |
1121 | | |
1122 | 2.32k | zend_generator_ensure_initialized(generator); |
1123 | | |
1124 | 2.32k | root = zend_generator_get_current(generator); |
1125 | | |
1126 | 2.32k | return &root->value; |
1127 | 2.32k | } |
1128 | | /* }}} */ |
1129 | | |
1130 | | static void zend_generator_iterator_get_key(zend_object_iterator *iterator, zval *key) /* {{{ */ |
1131 | 620 | { |
1132 | 620 | zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data), *root; |
1133 | | |
1134 | 620 | zend_generator_ensure_initialized(generator); |
1135 | | |
1136 | 620 | root = zend_generator_get_current(generator); |
1137 | | |
1138 | 620 | if (EXPECTED(Z_TYPE(root->key) != IS_UNDEF)) { |
1139 | 620 | zval *zv = &root->key; |
1140 | | |
1141 | 620 | ZVAL_COPY_DEREF(key, zv); |
1142 | 620 | } else { |
1143 | 0 | ZVAL_NULL(key); |
1144 | 0 | } |
1145 | 620 | } |
1146 | | /* }}} */ |
1147 | | |
1148 | | static void zend_generator_iterator_move_forward(zend_object_iterator *iterator) /* {{{ */ |
1149 | 2.13k | { |
1150 | 2.13k | zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data); |
1151 | | |
1152 | 2.13k | zend_generator_ensure_initialized(generator); |
1153 | | |
1154 | 2.13k | zend_generator_resume(generator); |
1155 | 2.13k | } |
1156 | | /* }}} */ |
1157 | | |
1158 | | static void zend_generator_iterator_rewind(zend_object_iterator *iterator) /* {{{ */ |
1159 | 1.10k | { |
1160 | 1.10k | zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data); |
1161 | | |
1162 | 1.10k | zend_generator_rewind(generator); |
1163 | 1.10k | } |
1164 | | /* }}} */ |
1165 | | |
1166 | | static HashTable *zend_generator_iterator_get_gc( |
1167 | | zend_object_iterator *iterator, zval **table, int *n) |
1168 | 142 | { |
1169 | 142 | *table = &iterator->data; |
1170 | 142 | *n = 1; |
1171 | 142 | return NULL; |
1172 | 142 | } |
1173 | | |
1174 | | static const zend_object_iterator_funcs zend_generator_iterator_functions = { |
1175 | | zend_generator_iterator_dtor, |
1176 | | zend_generator_iterator_valid, |
1177 | | zend_generator_iterator_get_data, |
1178 | | zend_generator_iterator_get_key, |
1179 | | zend_generator_iterator_move_forward, |
1180 | | zend_generator_iterator_rewind, |
1181 | | NULL, |
1182 | | zend_generator_iterator_get_gc, |
1183 | | }; |
1184 | | |
1185 | | /* by_ref is int due to Iterator API */ |
1186 | | static zend_object_iterator *zend_generator_get_iterator(zend_class_entry *ce, zval *object, int by_ref) /* {{{ */ |
1187 | 1.12k | { |
1188 | 1.12k | zend_object_iterator *iterator; |
1189 | 1.12k | zend_generator *generator = (zend_generator*)Z_OBJ_P(object); |
1190 | | |
1191 | 1.12k | if (!generator->execute_data) { |
1192 | 7 | zend_throw_exception(NULL, "Cannot traverse an already closed generator", 0); |
1193 | 7 | return NULL; |
1194 | 7 | } |
1195 | | |
1196 | 1.12k | if (UNEXPECTED(by_ref) && !(generator->execute_data->func->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) { |
1197 | 5 | zend_throw_exception(NULL, "You can only iterate a generator by-reference if it declared that it yields by-reference", 0); |
1198 | 5 | return NULL; |
1199 | 5 | } |
1200 | | |
1201 | 1.11k | iterator = emalloc(sizeof(zend_object_iterator)); |
1202 | 1.11k | zend_iterator_init(iterator); |
1203 | | |
1204 | 1.11k | iterator->funcs = &zend_generator_iterator_functions; |
1205 | 1.11k | ZVAL_OBJ_COPY(&iterator->data, Z_OBJ_P(object)); |
1206 | | |
1207 | 1.11k | return iterator; |
1208 | 1.12k | } |
1209 | | /* }}} */ |
1210 | | |
1211 | | void zend_register_generator_ce(void) /* {{{ */ |
1212 | 16 | { |
1213 | 16 | zend_ce_generator = register_class_Generator(zend_ce_iterator); |
1214 | 16 | zend_ce_generator->create_object = zend_generator_create; |
1215 | | /* get_iterator has to be assigned *after* implementing the interface */ |
1216 | 16 | zend_ce_generator->get_iterator = zend_generator_get_iterator; |
1217 | 16 | zend_ce_generator->default_object_handlers = &zend_generator_handlers; |
1218 | | |
1219 | 16 | memcpy(&zend_generator_handlers, &std_object_handlers, sizeof(zend_object_handlers)); |
1220 | 16 | zend_generator_handlers.free_obj = zend_generator_free_storage; |
1221 | 16 | zend_generator_handlers.dtor_obj = zend_generator_dtor_storage; |
1222 | 16 | zend_generator_handlers.get_gc = zend_generator_get_gc; |
1223 | 16 | zend_generator_handlers.clone_obj = NULL; |
1224 | 16 | zend_generator_handlers.get_constructor = zend_generator_get_constructor; |
1225 | | |
1226 | 16 | zend_ce_ClosedGeneratorException = register_class_ClosedGeneratorException(zend_ce_exception); |
1227 | 16 | } |
1228 | | /* }}} */ |