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