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