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 = emalloc(sizeof(zend_generator));
408 memset(generator, 0, sizeof(zend_generator));
409
410 /* The key will be incremented on first use, so it'll start at 0 */
411 generator->largest_used_integer_key = -1;
412
413 ZVAL_UNDEF(&generator->retval);
414 ZVAL_UNDEF(&generator->values);
415
416 /* By default we have a tree of only one node */
417 generator->node.parent = NULL;
418 generator->node.children = 0;
419 generator->node.ptr.root = NULL;
420
421 zend_object_std_init(&generator->std, class_type);
422 return (zend_object*)generator;
423 }
424 /* }}} */
425
zend_generator_get_constructor(zend_object * object)426 static ZEND_COLD zend_function *zend_generator_get_constructor(zend_object *object) /* {{{ */
427 {
428 zend_throw_error(NULL, "The \"Generator\" class is reserved for internal use and cannot be manually instantiated");
429
430 return NULL;
431 }
432 /* }}} */
433
zend_generator_check_placeholder_frame(zend_execute_data * ptr)434 ZEND_API zend_execute_data *zend_generator_check_placeholder_frame(zend_execute_data *ptr)
435 {
436 if (!ptr->func && Z_TYPE(ptr->This) == IS_OBJECT) {
437 if (Z_OBJCE(ptr->This) == zend_ce_generator) {
438 zend_generator *generator = (zend_generator *) Z_OBJ(ptr->This);
439 zend_execute_data *prev = ptr->prev_execute_data;
440 ZEND_ASSERT(generator->node.parent && "Placeholder only used with delegation");
441 while (generator->node.parent->node.parent) {
442 generator->execute_data->prev_execute_data = prev;
443 prev = generator->execute_data;
444 generator = generator->node.parent;
445 }
446 generator->execute_data->prev_execute_data = prev;
447 ptr = generator->execute_data;
448 }
449 }
450 return ptr;
451 }
452
zend_generator_throw_exception(zend_generator * generator,zval * exception)453 static void zend_generator_throw_exception(zend_generator *generator, zval *exception)
454 {
455 zend_execute_data *original_execute_data = EG(current_execute_data);
456
457 /* Throw the exception in the context of the generator. Decrementing the opline
458 * to pretend the exception happened during the YIELD opcode. */
459 EG(current_execute_data) = generator->execute_data;
460 generator->execute_data->opline--;
461
462 if (exception) {
463 zend_throw_exception_object(exception);
464 } else {
465 zend_rethrow_exception(EG(current_execute_data));
466 }
467
468 /* if we don't stop an array/iterator yield from, the exception will only reach the generator after the values were all iterated over */
469 if (UNEXPECTED(Z_TYPE(generator->values) != IS_UNDEF)) {
470 zval_ptr_dtor(&generator->values);
471 ZVAL_UNDEF(&generator->values);
472 }
473
474 generator->execute_data->opline++;
475 EG(current_execute_data) = original_execute_data;
476 }
477
zend_generator_add_child(zend_generator * generator,zend_generator * child)478 static void zend_generator_add_child(zend_generator *generator, zend_generator *child)
479 {
480 zend_generator_node *node = &generator->node;
481
482 if (node->children == 0) {
483 node->child.single = child;
484 } else {
485 if (node->children == 1) {
486 HashTable *ht = emalloc(sizeof(HashTable));
487 zend_hash_init(ht, 0, NULL, NULL, 0);
488 zend_hash_index_add_new_ptr(ht,
489 (zend_ulong) node->child.single, node->child.single);
490 node->child.ht = ht;
491 }
492
493 zend_hash_index_add_new_ptr(node->child.ht, (zend_ulong) child, child);
494 }
495
496 ++node->children;
497 }
498
zend_generator_yield_from(zend_generator * generator,zend_generator * from)499 void zend_generator_yield_from(zend_generator *generator, zend_generator *from)
500 {
501 ZEND_ASSERT(!generator->node.parent && "Already has parent?");
502 zend_generator *leaf = clear_link_to_leaf(generator);
503 if (leaf && !from->node.parent && !from->node.ptr.leaf) {
504 from->node.ptr.leaf = leaf;
505 leaf->node.ptr.root = from;
506 }
507 generator->node.parent = from;
508 zend_generator_add_child(from, generator);
509 generator->flags |= ZEND_GENERATOR_DO_INIT;
510 }
511
zend_generator_update_root(zend_generator * generator)512 ZEND_API zend_generator *zend_generator_update_root(zend_generator *generator)
513 {
514 zend_generator *root = generator->node.parent;
515 while (root->node.parent) {
516 root = root->node.parent;
517 }
518
519 clear_link_to_leaf(root);
520 root->node.ptr.leaf = generator;
521 generator->node.ptr.root = root;
522 return root;
523 }
524
get_new_root(zend_generator * generator,zend_generator * root)525 static zend_generator *get_new_root(zend_generator *generator, zend_generator *root)
526 {
527 while (!root->execute_data && root->node.children == 1) {
528 root = root->node.child.single;
529 }
530
531 if (root->execute_data) {
532 return root;
533 }
534
535 /* We have reached a multi-child node haven't found the root yet. We don't know which
536 * child to follow, so perform the search from the other direction instead. */
537 while (generator->node.parent->execute_data) {
538 generator = generator->node.parent;
539 }
540
541 return generator;
542 }
543
zend_generator_update_current(zend_generator * generator)544 ZEND_API zend_generator *zend_generator_update_current(zend_generator *generator)
545 {
546 zend_generator *old_root = generator->node.ptr.root;
547 ZEND_ASSERT(!old_root->execute_data && "Nothing to update?");
548
549 zend_generator *new_root = get_new_root(generator, old_root);
550
551 ZEND_ASSERT(old_root->node.ptr.leaf == generator);
552 generator->node.ptr.root = new_root;
553 new_root->node.ptr.leaf = generator;
554 old_root->node.ptr.leaf = NULL;
555
556 zend_generator *new_root_parent = new_root->node.parent;
557 ZEND_ASSERT(new_root_parent);
558 zend_generator_remove_child(&new_root_parent->node, new_root);
559
560 if (EXPECTED(EG(exception) == NULL) && EXPECTED((OBJ_FLAGS(&generator->std) & IS_OBJ_DESTRUCTOR_CALLED) == 0)) {
561 zend_op *yield_from = (zend_op *) new_root->execute_data->opline - 1;
562
563 if (yield_from->opcode == ZEND_YIELD_FROM) {
564 if (Z_ISUNDEF(new_root_parent->retval)) {
565 /* Throw the exception in the context of the generator */
566 zend_execute_data *original_execute_data = EG(current_execute_data);
567 EG(current_execute_data) = new_root->execute_data;
568
569 if (new_root == generator) {
570 new_root->execute_data->prev_execute_data = original_execute_data;
571 } else {
572 new_root->execute_data->prev_execute_data = &generator->execute_fake;
573 generator->execute_fake.prev_execute_data = original_execute_data;
574 }
575
576 /* ZEND_YIELD(_FROM) already advance, so decrement opline to throw from correct place */
577 new_root->execute_data->opline--;
578 zend_throw_exception(zend_ce_ClosedGeneratorException, "Generator yielded from aborted, no return value available", 0);
579
580 EG(current_execute_data) = original_execute_data;
581
582 if (!(old_root->flags & ZEND_GENERATOR_CURRENTLY_RUNNING)) {
583 new_root->node.parent = NULL;
584 OBJ_RELEASE(&new_root_parent->std);
585 zend_generator_resume(generator);
586 return zend_generator_get_current(generator);
587 }
588 } else {
589 zval_ptr_dtor(&new_root->value);
590 ZVAL_COPY(&new_root->value, &new_root_parent->value);
591 ZVAL_COPY(ZEND_CALL_VAR(new_root->execute_data, yield_from->result.var), &new_root_parent->retval);
592 }
593 }
594 }
595
596 new_root->node.parent = NULL;
597 OBJ_RELEASE(&new_root_parent->std);
598
599 return new_root;
600 }
601
zend_generator_get_next_delegated_value(zend_generator * generator)602 static zend_result zend_generator_get_next_delegated_value(zend_generator *generator) /* {{{ */
603 {
604 --generator->execute_data->opline;
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 if (HT_IS_PACKED(ht)) {
612 do {
613 if (UNEXPECTED(pos >= ht->nNumUsed)) {
614 /* Reached end of array */
615 goto failure;
616 }
617
618 value = &ht->arPacked[pos];
619 pos++;
620 } while (Z_ISUNDEF_P(value));
621
622 zval_ptr_dtor(&generator->value);
623 ZVAL_COPY(&generator->value, value);
624
625 zval_ptr_dtor(&generator->key);
626 ZVAL_LONG(&generator->key, pos - 1);
627 } else {
628 Bucket *p;
629
630 do {
631 if (UNEXPECTED(pos >= ht->nNumUsed)) {
632 /* Reached end of array */
633 goto failure;
634 }
635
636 p = &ht->arData[pos];
637 value = &p->val;
638 pos++;
639 } while (Z_ISUNDEF_P(value));
640
641 zval_ptr_dtor(&generator->value);
642 ZVAL_COPY(&generator->value, value);
643
644 zval_ptr_dtor(&generator->key);
645 if (p->key) {
646 ZVAL_STR_COPY(&generator->key, p->key);
647 } else {
648 ZVAL_LONG(&generator->key, p->h);
649 }
650 }
651 Z_FE_POS(generator->values) = pos;
652 } else {
653 zend_object_iterator *iter = (zend_object_iterator *) Z_OBJ(generator->values);
654
655 if (iter->index++ > 0) {
656 iter->funcs->move_forward(iter);
657 if (UNEXPECTED(EG(exception) != NULL)) {
658 goto failure;
659 }
660 }
661
662 if (iter->funcs->valid(iter) == FAILURE) {
663 /* reached end of iteration */
664 goto failure;
665 }
666
667 value = iter->funcs->get_current_data(iter);
668 if (UNEXPECTED(EG(exception) != NULL) || UNEXPECTED(!value)) {
669 goto failure;
670 }
671
672 zval_ptr_dtor(&generator->value);
673 ZVAL_COPY(&generator->value, value);
674
675 zval_ptr_dtor(&generator->key);
676 if (iter->funcs->get_current_key) {
677 iter->funcs->get_current_key(iter, &generator->key);
678 if (UNEXPECTED(EG(exception) != NULL)) {
679 ZVAL_UNDEF(&generator->key);
680 goto failure;
681 }
682 } else {
683 ZVAL_LONG(&generator->key, iter->index);
684 }
685 }
686
687 ++generator->execute_data->opline;
688 return SUCCESS;
689
690 failure:
691 zval_ptr_dtor(&generator->values);
692 ZVAL_UNDEF(&generator->values);
693
694 ++generator->execute_data->opline;
695 return FAILURE;
696 }
697 /* }}} */
698
zend_generator_resume(zend_generator * orig_generator)699 ZEND_API void zend_generator_resume(zend_generator *orig_generator) /* {{{ */
700 {
701 zend_generator *generator = zend_generator_get_current(orig_generator);
702
703 /* The generator is already closed, thus can't resume */
704 if (UNEXPECTED(!generator->execute_data)) {
705 return;
706 }
707
708 try_again:
709 if (generator->flags & ZEND_GENERATOR_CURRENTLY_RUNNING) {
710 zend_throw_error(NULL, "Cannot resume an already running generator");
711 return;
712 }
713
714 if (UNEXPECTED((orig_generator->flags & ZEND_GENERATOR_DO_INIT) != 0 && !Z_ISUNDEF(generator->value))) {
715 /* We must not advance Generator if we yield from a Generator being currently run */
716 orig_generator->flags &= ~ZEND_GENERATOR_DO_INIT;
717 return;
718 }
719
720 /* Drop the AT_FIRST_YIELD flag */
721 orig_generator->flags &= ~ZEND_GENERATOR_AT_FIRST_YIELD;
722
723 /* Backup executor globals */
724 zend_execute_data *original_execute_data = EG(current_execute_data);
725 uint32_t original_jit_trace_num = EG(jit_trace_num);
726
727 /* Set executor globals */
728 EG(current_execute_data) = generator->execute_data;
729 EG(jit_trace_num) = 0;
730
731 /* We want the backtrace to look as if the generator function was
732 * called from whatever method we are current running (e.g. next()).
733 * So we have to link generator call frame with caller call frame. */
734 if (generator == orig_generator) {
735 generator->execute_data->prev_execute_data = original_execute_data;
736 } else {
737 /* We need some execute_data placeholder in stacktrace to be replaced
738 * by the real stack trace when needed */
739 generator->execute_data->prev_execute_data = &orig_generator->execute_fake;
740 orig_generator->execute_fake.prev_execute_data = original_execute_data;
741 }
742
743 /* Ensure this is run after executor_data swap to have a proper stack trace */
744 if (UNEXPECTED(!Z_ISUNDEF(generator->values))) {
745 if (EXPECTED(zend_generator_get_next_delegated_value(generator) == SUCCESS)) {
746 /* Restore executor globals */
747 EG(current_execute_data) = original_execute_data;
748 EG(jit_trace_num) = original_jit_trace_num;
749
750 orig_generator->flags &= ~ZEND_GENERATOR_DO_INIT;
751 return;
752 }
753 /* If there are no more delegated values, resume the generator
754 * after the "yield from" expression. */
755 }
756
757 if (UNEXPECTED(generator->frozen_call_stack)) {
758 /* Restore frozen call-stack */
759 zend_generator_restore_call_stack(generator);
760 }
761
762 /* Resume execution */
763 generator->flags |= ZEND_GENERATOR_CURRENTLY_RUNNING
764 | (EG(active_fiber) ? ZEND_GENERATOR_IN_FIBER : 0);
765 if (!ZEND_OBSERVER_ENABLED) {
766 zend_execute_ex(generator->execute_data);
767 } else {
768 zend_observer_generator_resume(generator->execute_data);
769 zend_execute_ex(generator->execute_data);
770 if (generator->execute_data) {
771 /* On the final return, this will be called from ZEND_GENERATOR_RETURN */
772 zend_observer_fcall_end(generator->execute_data, &generator->value);
773 }
774 }
775 generator->flags &= ~(ZEND_GENERATOR_CURRENTLY_RUNNING | ZEND_GENERATOR_IN_FIBER);
776
777 generator->frozen_call_stack = NULL;
778 if (EXPECTED(generator->execute_data) &&
779 UNEXPECTED(generator->execute_data->call)) {
780 /* Frize call-stack */
781 generator->frozen_call_stack = zend_generator_freeze_call_stack(generator->execute_data);
782 }
783
784 /* Restore executor globals */
785 EG(current_execute_data) = original_execute_data;
786 EG(jit_trace_num) = original_jit_trace_num;
787
788 /* If an exception was thrown in the generator we have to internally
789 * rethrow it in the parent scope.
790 * In case we did yield from, the Exception must be rethrown into
791 * its calling frame (see above in if (check_yield_from). */
792 if (UNEXPECTED(EG(exception) != NULL)) {
793 if (generator == orig_generator) {
794 zend_generator_close(generator, 0);
795 if (!EG(current_execute_data)) {
796 zend_throw_exception_internal(NULL);
797 } else if (EG(current_execute_data)->func &&
798 ZEND_USER_CODE(EG(current_execute_data)->func->common.type)) {
799 zend_rethrow_exception(EG(current_execute_data));
800 }
801 } else {
802 generator = zend_generator_get_current(orig_generator);
803 zend_generator_throw_exception(generator, NULL);
804 orig_generator->flags &= ~ZEND_GENERATOR_DO_INIT;
805 goto try_again;
806 }
807 }
808
809 /* yield from was used, try another resume. */
810 if (UNEXPECTED((generator != orig_generator && !Z_ISUNDEF(generator->retval)) || (generator->execute_data && (generator->execute_data->opline - 1)->opcode == ZEND_YIELD_FROM))) {
811 generator = zend_generator_get_current(orig_generator);
812 goto try_again;
813 }
814
815 orig_generator->flags &= ~ZEND_GENERATOR_DO_INIT;
816 }
817 /* }}} */
818
zend_generator_ensure_initialized(zend_generator * generator)819 static inline void zend_generator_ensure_initialized(zend_generator *generator) /* {{{ */
820 {
821 if (UNEXPECTED(Z_TYPE(generator->value) == IS_UNDEF) && EXPECTED(generator->execute_data) && EXPECTED(generator->node.parent == NULL)) {
822 zend_generator_resume(generator);
823 generator->flags |= ZEND_GENERATOR_AT_FIRST_YIELD;
824 }
825 }
826 /* }}} */
827
zend_generator_rewind(zend_generator * generator)828 static inline void zend_generator_rewind(zend_generator *generator) /* {{{ */
829 {
830 zend_generator_ensure_initialized(generator);
831
832 if (!(generator->flags & ZEND_GENERATOR_AT_FIRST_YIELD)) {
833 zend_throw_exception(NULL, "Cannot rewind a generator that was already run", 0);
834 }
835 }
836 /* }}} */
837
838 /* {{{ Rewind the generator */
ZEND_METHOD(Generator,rewind)839 ZEND_METHOD(Generator, rewind)
840 {
841 zend_generator *generator;
842
843 ZEND_PARSE_PARAMETERS_NONE();
844
845 generator = (zend_generator *) Z_OBJ_P(ZEND_THIS);
846
847 zend_generator_rewind(generator);
848 }
849 /* }}} */
850
851 /* {{{ Check whether the generator is valid */
ZEND_METHOD(Generator,valid)852 ZEND_METHOD(Generator, valid)
853 {
854 zend_generator *generator;
855
856 ZEND_PARSE_PARAMETERS_NONE();
857
858 generator = (zend_generator *) Z_OBJ_P(ZEND_THIS);
859
860 zend_generator_ensure_initialized(generator);
861
862 zend_generator_get_current(generator);
863
864 RETURN_BOOL(EXPECTED(generator->execute_data != NULL));
865 }
866 /* }}} */
867
868 /* {{{ Get the current value */
ZEND_METHOD(Generator,current)869 ZEND_METHOD(Generator, current)
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->value) != IS_UNDEF)) {
881 RETURN_COPY_DEREF(&root->value);
882 }
883 }
884 /* }}} */
885
886 /* {{{ Get the current key */
ZEND_METHOD(Generator,key)887 ZEND_METHOD(Generator, key)
888 {
889 zend_generator *generator, *root;
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 root = zend_generator_get_current(generator);
898 if (EXPECTED(generator->execute_data != NULL && Z_TYPE(root->key) != IS_UNDEF)) {
899 RETURN_COPY_DEREF(&root->key);
900 }
901 }
902 /* }}} */
903
904 /* {{{ Advances the generator */
ZEND_METHOD(Generator,next)905 ZEND_METHOD(Generator, next)
906 {
907 zend_generator *generator;
908
909 ZEND_PARSE_PARAMETERS_NONE();
910
911 generator = (zend_generator *) Z_OBJ_P(ZEND_THIS);
912
913 zend_generator_ensure_initialized(generator);
914
915 zend_generator_resume(generator);
916 }
917 /* }}} */
918
919 /* {{{ Sends a value to the generator */
ZEND_METHOD(Generator,send)920 ZEND_METHOD(Generator, send)
921 {
922 zval *value;
923 zend_generator *generator, *root;
924
925 ZEND_PARSE_PARAMETERS_START(1, 1)
926 Z_PARAM_ZVAL(value)
927 ZEND_PARSE_PARAMETERS_END();
928
929 generator = (zend_generator *) Z_OBJ_P(ZEND_THIS);
930
931 zend_generator_ensure_initialized(generator);
932
933 /* The generator is already closed, thus can't send anything */
934 if (UNEXPECTED(!generator->execute_data)) {
935 return;
936 }
937
938 root = zend_generator_get_current(generator);
939 /* Put sent value in the target VAR slot, if it is used */
940 if (root->send_target && !(root->flags & ZEND_GENERATOR_CURRENTLY_RUNNING)) {
941 ZVAL_COPY(root->send_target, value);
942 }
943
944 zend_generator_resume(generator);
945
946 root = zend_generator_get_current(generator);
947 if (EXPECTED(generator->execute_data)) {
948 RETURN_COPY_DEREF(&root->value);
949 }
950 }
951 /* }}} */
952
953 /* {{{ Throws an exception into the generator */
ZEND_METHOD(Generator,throw)954 ZEND_METHOD(Generator, throw)
955 {
956 zval *exception;
957 zend_generator *generator;
958
959 ZEND_PARSE_PARAMETERS_START(1, 1)
960 Z_PARAM_OBJECT_OF_CLASS(exception, zend_ce_throwable);
961 ZEND_PARSE_PARAMETERS_END();
962
963 Z_TRY_ADDREF_P(exception);
964
965 generator = (zend_generator *) Z_OBJ_P(ZEND_THIS);
966
967 zend_generator_ensure_initialized(generator);
968
969 if (generator->execute_data) {
970 zend_generator *root = zend_generator_get_current(generator);
971
972 zend_generator_throw_exception(root, exception);
973
974 zend_generator_resume(generator);
975
976 root = zend_generator_get_current(generator);
977 if (generator->execute_data) {
978 RETURN_COPY_DEREF(&root->value);
979 }
980 } else {
981 /* If the generator is already closed throw the exception in the
982 * current context */
983 zend_throw_exception_object(exception);
984 }
985 }
986 /* }}} */
987
988 /* {{{ Retrieves the return value of the generator */
ZEND_METHOD(Generator,getReturn)989 ZEND_METHOD(Generator, getReturn)
990 {
991 zend_generator *generator;
992
993 ZEND_PARSE_PARAMETERS_NONE();
994
995 generator = (zend_generator *) Z_OBJ_P(ZEND_THIS);
996
997 zend_generator_ensure_initialized(generator);
998 if (UNEXPECTED(EG(exception))) {
999 return;
1000 }
1001
1002 if (Z_ISUNDEF(generator->retval)) {
1003 /* Generator hasn't returned yet -> error! */
1004 zend_throw_exception(NULL,
1005 "Cannot get return value of a generator that hasn't returned", 0);
1006 return;
1007 }
1008
1009 ZVAL_COPY(return_value, &generator->retval);
1010 }
1011 /* }}} */
1012
1013 /* get_iterator implementation */
1014
zend_generator_iterator_dtor(zend_object_iterator * iterator)1015 static void zend_generator_iterator_dtor(zend_object_iterator *iterator) /* {{{ */
1016 {
1017 zval_ptr_dtor(&iterator->data);
1018 }
1019 /* }}} */
1020
zend_generator_iterator_valid(zend_object_iterator * iterator)1021 static zend_result zend_generator_iterator_valid(zend_object_iterator *iterator) /* {{{ */
1022 {
1023 zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
1024
1025 zend_generator_ensure_initialized(generator);
1026
1027 zend_generator_get_current(generator);
1028
1029 return generator->execute_data ? SUCCESS : FAILURE;
1030 }
1031 /* }}} */
1032
zend_generator_iterator_get_data(zend_object_iterator * iterator)1033 static zval *zend_generator_iterator_get_data(zend_object_iterator *iterator) /* {{{ */
1034 {
1035 zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data), *root;
1036
1037 zend_generator_ensure_initialized(generator);
1038
1039 root = zend_generator_get_current(generator);
1040
1041 return &root->value;
1042 }
1043 /* }}} */
1044
zend_generator_iterator_get_key(zend_object_iterator * iterator,zval * key)1045 static void zend_generator_iterator_get_key(zend_object_iterator *iterator, zval *key) /* {{{ */
1046 {
1047 zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data), *root;
1048
1049 zend_generator_ensure_initialized(generator);
1050
1051 root = zend_generator_get_current(generator);
1052
1053 if (EXPECTED(Z_TYPE(root->key) != IS_UNDEF)) {
1054 zval *zv = &root->key;
1055
1056 ZVAL_COPY_DEREF(key, zv);
1057 } else {
1058 ZVAL_NULL(key);
1059 }
1060 }
1061 /* }}} */
1062
zend_generator_iterator_move_forward(zend_object_iterator * iterator)1063 static void zend_generator_iterator_move_forward(zend_object_iterator *iterator) /* {{{ */
1064 {
1065 zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
1066
1067 zend_generator_ensure_initialized(generator);
1068
1069 zend_generator_resume(generator);
1070 }
1071 /* }}} */
1072
zend_generator_iterator_rewind(zend_object_iterator * iterator)1073 static void zend_generator_iterator_rewind(zend_object_iterator *iterator) /* {{{ */
1074 {
1075 zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
1076
1077 zend_generator_rewind(generator);
1078 }
1079 /* }}} */
1080
zend_generator_iterator_get_gc(zend_object_iterator * iterator,zval ** table,int * n)1081 static HashTable *zend_generator_iterator_get_gc(
1082 zend_object_iterator *iterator, zval **table, int *n)
1083 {
1084 *table = &iterator->data;
1085 *n = 1;
1086 return NULL;
1087 }
1088
1089 static const zend_object_iterator_funcs zend_generator_iterator_functions = {
1090 zend_generator_iterator_dtor,
1091 zend_generator_iterator_valid,
1092 zend_generator_iterator_get_data,
1093 zend_generator_iterator_get_key,
1094 zend_generator_iterator_move_forward,
1095 zend_generator_iterator_rewind,
1096 NULL,
1097 zend_generator_iterator_get_gc,
1098 };
1099
1100 /* by_ref is int due to Iterator API */
zend_generator_get_iterator(zend_class_entry * ce,zval * object,int by_ref)1101 zend_object_iterator *zend_generator_get_iterator(zend_class_entry *ce, zval *object, int by_ref) /* {{{ */
1102 {
1103 zend_object_iterator *iterator;
1104 zend_generator *generator = (zend_generator*)Z_OBJ_P(object);
1105
1106 if (!generator->execute_data) {
1107 zend_throw_exception(NULL, "Cannot traverse an already closed generator", 0);
1108 return NULL;
1109 }
1110
1111 if (UNEXPECTED(by_ref) && !(generator->execute_data->func->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
1112 zend_throw_exception(NULL, "You can only iterate a generator by-reference if it declared that it yields by-reference", 0);
1113 return NULL;
1114 }
1115
1116 iterator = emalloc(sizeof(zend_object_iterator));
1117 zend_iterator_init(iterator);
1118
1119 iterator->funcs = &zend_generator_iterator_functions;
1120 ZVAL_OBJ_COPY(&iterator->data, Z_OBJ_P(object));
1121
1122 return iterator;
1123 }
1124 /* }}} */
1125
zend_register_generator_ce(void)1126 void zend_register_generator_ce(void) /* {{{ */
1127 {
1128 zend_ce_generator = register_class_Generator(zend_ce_iterator);
1129 zend_ce_generator->create_object = zend_generator_create;
1130 /* get_iterator has to be assigned *after* implementing the interface */
1131 zend_ce_generator->get_iterator = zend_generator_get_iterator;
1132 zend_ce_generator->default_object_handlers = &zend_generator_handlers;
1133
1134 memcpy(&zend_generator_handlers, &std_object_handlers, sizeof(zend_object_handlers));
1135 zend_generator_handlers.free_obj = zend_generator_free_storage;
1136 zend_generator_handlers.dtor_obj = zend_generator_dtor_storage;
1137 zend_generator_handlers.get_gc = zend_generator_get_gc;
1138 zend_generator_handlers.clone_obj = NULL;
1139 zend_generator_handlers.get_constructor = zend_generator_get_constructor;
1140
1141 zend_ce_ClosedGeneratorException = register_class_ClosedGeneratorException(zend_ce_exception);
1142 }
1143 /* }}} */
1144