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