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