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