1 files changed, 178 insertions, 228 deletions

diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c
index e8b1be4445..b38657f7b7 100644
--- a/Zend/zend_generators.c
+++ b/Zend/zend_generators.c
@@ -2,7 +2,7 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
    | This source file is subject to version 2.00 of the Zend license,     |
    | that is bundled with this package in the file LICENSE, and is        |
@@ -27,23 +27,70 @@
 ZEND_API zend_class_entry *zend_ce_generator;
 static zend_object_handlers zend_generator_handlers;
 
-static zend_object_value zend_generator_create(zend_class_entry *class_type TSRMLS_DC);
+static zend_object *zend_generator_create(zend_class_entry *class_type TSRMLS_DC);
+
+static void zend_generator_cleanup_unfinished_execution(zend_generator *generator TSRMLS_DC) /* {{{ */
+{
+	zend_execute_data *execute_data = generator->execute_data;
+	zend_op_array *op_array = &execute_data->func->op_array;
+
+	if (generator->send_target) {
+		if (Z_REFCOUNTED_P(generator->send_target)) Z_DELREF_P(generator->send_target);
+		generator->send_target = NULL;
+	}
+
+	/* Manually free loop variables, as execution couldn't reach their
+	 * SWITCH_FREE / FREE opcodes. */
+	{
+		/* -1 required because we want the last run opcode, not the
+		 * next to-be-run one. */
+		uint32_t op_num = execute_data->opline - op_array->opcodes - 1;
+
+		int i;
+		for (i = 0; i < op_array->last_brk_cont; ++i) {
+			zend_brk_cont_element *brk_cont = op_array->brk_cont_array + i;
+
+			if (brk_cont->start < 0) {
+				continue;
+			} else if ((uint32_t)brk_cont->start > op_num) {
+				break;
+			} else if (brk_cont->brk >= 0 && (uint32_t)brk_cont->brk > op_num) {
+				zend_op *brk_opline = op_array->opcodes + brk_cont->brk;
+
+				if (brk_opline->opcode == ZEND_FREE) {
+					zval *var = EX_VAR_2(execute_data, brk_opline->op1.var);
+					zval_ptr_dtor_nogc(var);
+				}
+			}
+		}
+	}
+
+	/* If yield was used as a function argument there may be active
+	 * method calls those objects need to be freed */
+	while (execute_data->call) {
+		if (Z_OBJ(execute_data->call->This)) {
+			OBJ_RELEASE(Z_OBJ(execute_data->call->This));
+		}
+		execute_data->call = execute_data->call->prev_execute_data;
+	}
+}
+/* }}} */
 
 ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished_execution TSRMLS_DC) /* {{{ */
 {
-	if (generator->value) {
+	if (Z_TYPE(generator->value) != IS_UNDEF) {
 		zval_ptr_dtor(&generator->value);
-		generator->value = NULL;
+		ZVAL_UNDEF(&generator->value);
 	}
 
-	if (generator->key) {
+	if (Z_TYPE(generator->key) != IS_UNDEF) {
 		zval_ptr_dtor(&generator->key);
-		generator->key = NULL;
+		ZVAL_UNDEF(&generator->key);
 	}
 
 	if (generator->execute_data) {
 		zend_execute_data *execute_data = generator->execute_data;
-		zend_op_array *op_array = execute_data->op_array;
+		zend_op_array *op_array = &execute_data->func->op_array;
 
 		if (!execute_data->symbol_table) {
 			zend_free_compiled_variables(execute_data TSRMLS_CC);
@@ -51,127 +98,56 @@ ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished
 			zend_clean_and_cache_symbol_table(execute_data->symbol_table TSRMLS_CC);
 		}
 
-		if (execute_data->current_this) {
-			zval_ptr_dtor(&execute_data->current_this);
+		if (Z_OBJ(execute_data->This)) {
+			OBJ_RELEASE(Z_OBJ(execute_data->This));
 		}
 
 		/* A fatal error / die occurred during the generator execution. Trying to clean
 		 * up the stack may not be safe in this case. */
 		if (CG(unclean_shutdown)) {
+			generator->execute_data = NULL;
 			return;
 		}
 
-		/* If the generator is closed before it can finish execution (reach
-		 * a return statement) we have to free loop variables manually, as
-		 * we don't know whether the SWITCH_FREE / FREE opcodes have run */
-		if (!finished_execution) {
-			/* -1 required because we want the last run opcode, not the
-			 * next to-be-run one. */
-			zend_uint op_num = execute_data->opline - op_array->opcodes - 1;
-
-			int i;
-			for (i = 0; i < op_array->last_brk_cont; ++i) {
-				zend_brk_cont_element *brk_cont = op_array->brk_cont_array + i;
-
-				if (brk_cont->start < 0) {
-					continue;
-				} else if (brk_cont->start > op_num) {
-					break;
-				} else if (brk_cont->brk > op_num) {
-					zend_op *brk_opline = op_array->opcodes + brk_cont->brk;
-
-					switch (brk_opline->opcode) {
-						case ZEND_SWITCH_FREE:
-							{
-								temp_variable *var = EX_TMP_VAR(execute_data, brk_opline->op1.var);
-								zval_ptr_dtor(&var->var.ptr);
-							}
-							break;
-						case ZEND_FREE:
-							{
-								temp_variable *var = EX_TMP_VAR(execute_data, brk_opline->op1.var);
-								zval_dtor(&var->tmp_var);
-							}
-							break;
-					}
-				}
-			}
-		}
-
-		/* Clear any backed up stack arguments */
-		if (generator->stack != EG(argument_stack)) {
-			void **ptr = generator->stack->top - 1;
-			void **end = zend_vm_stack_frame_base(execute_data);
-
-			/* If the top stack element is the argument count, skip it */
-			if (execute_data->function_state.arguments) {
-				ptr--;
-			}
-
-			for (; ptr >= end; --ptr) {
-				zval_ptr_dtor((zval**) ptr);
-			}
-		}
-
-		while (execute_data->call >= execute_data->call_slots) {
-			if (execute_data->call->object) {
-				zval_ptr_dtor(&execute_data->call->object);
-			}
-			execute_data->call--;
-		}
+		zend_vm_stack_free_extra_args(generator->execute_data TSRMLS_CC);
 
-		/* We have added an additional stack frame in prev_execute_data, so we
-		 * have to free it. It also contains the arguments passed to the
-		 * generator (for func_get_args) so those have to be freed too. */
-		{
-			zend_execute_data *prev_execute_data = execute_data->prev_execute_data;
-			void **arguments = prev_execute_data->function_state.arguments;
-
-			if (arguments) {
-				int arguments_count = (int) (zend_uintptr_t) *arguments;
-				zval **arguments_start = (zval **) (arguments - arguments_count);
-				int i;
-
-				for (i = 0; i < arguments_count; ++i) {
-					zval_ptr_dtor(arguments_start + i);
-				}
-			}
+		/* Some cleanups are only necessary if the generator was closued
+		 * before it could finish execution (reach a return statement). */
+		if (!finished_execution) {
+			zend_generator_cleanup_unfinished_execution(generator TSRMLS_CC);
 		}
 
 		/* Free a clone of closure */
 		if (op_array->fn_flags & ZEND_ACC_CLOSURE) {
 			destroy_op_array(op_array TSRMLS_CC);
-			efree(op_array);
+			efree_size(op_array, sizeof(zend_op_array));
 		}
 
 		efree(generator->stack);
-		if (generator->stack == EG(argument_stack)) {
-			/* abnormal exit for running generator */
-			EG(argument_stack) = NULL;
-		}
 		generator->execute_data = NULL;
 	}
 }
 /* }}} */
 
-static void zend_generator_dtor_storage(zend_generator *generator, zend_object_handle handle TSRMLS_DC) /* {{{ */
+static void zend_generator_dtor_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
+	zend_generator *generator = (zend_generator*) object;
 	zend_execute_data *ex = generator->execute_data;
-	zend_uint op_num, finally_op_num;
+	uint32_t op_num, finally_op_num;
 	int i;
 
-	if (!ex || !ex->op_array->has_finally_block) {
+	if (!ex || !(ex->func->op_array.fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK)) {
 		return;
 	}
 
 	/* -1 required because we want the last run opcode, not the
 	 * next to-be-run one. */
-	op_num = ex->opline - ex->op_array->opcodes - 1;
+	op_num = ex->opline - ex->func->op_array.opcodes - 1;
 
 	/* Find next finally block */
 	finally_op_num = 0;
-	for (i = 0; i < ex->op_array->last_try_catch; i++) {
-		zend_try_catch_element *try_catch = &ex->op_array->try_catch_array[i];
+	for (i = 0; i < ex->func->op_array.last_try_catch; i++) {
+		zend_try_catch_element *try_catch = &ex->func->op_array.try_catch_array[i];
 
 		if (op_num < try_catch->try_op) {
 			break;
@@ -185,7 +161,7 @@ static void zend_generator_dtor_storage(zend_generator *generator, zend_object_h
 	/* If a finally block was found we jump directly to it and
 	 * resume the generator. */
 	if (finally_op_num) {
-		ex->opline = &ex->op_array->opcodes[finally_op_num];
+		ex->opline = &ex->func->op_array.opcodes[finally_op_num];
 		ex->fast_ret = NULL;
 		generator->flags |= ZEND_GENERATOR_FORCED_CLOSE;
 		zend_generator_resume(generator TSRMLS_CC);
@@ -193,19 +169,23 @@ static void zend_generator_dtor_storage(zend_generator *generator, zend_object_h
 }
 /* }}} */
 
-static void zend_generator_free_storage(zend_generator *generator TSRMLS_DC) /* {{{ */
+static void zend_generator_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
+	zend_generator *generator = (zend_generator*) object;
+
 	zend_generator_close(generator, 0 TSRMLS_CC);
 
 	zend_object_std_dtor(&generator->std TSRMLS_CC);
-	efree(generator);
+
+	if (generator->iterator) {
+		zend_iterator_dtor(generator->iterator TSRMLS_CC);
+	}
 }
 /* }}} */
 
-static zend_object_value zend_generator_create(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *zend_generator_create(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
 	zend_generator *generator;
-	zend_object_value object;
 
 	generator = emalloc(sizeof(zend_generator));
 	memset(generator, 0, sizeof(zend_generator));
@@ -214,40 +194,32 @@ static zend_object_value zend_generator_create(zend_class_entry *class_type TSRM
 	generator->largest_used_integer_key = -1;
 
 	zend_object_std_init(&generator->std, class_type TSRMLS_CC);
+	generator->std.handlers = &zend_generator_handlers;
 
-	object.handle = zend_objects_store_put(generator,
-		(zend_objects_store_dtor_t)          zend_generator_dtor_storage,
-		(zend_objects_free_object_storage_t) zend_generator_free_storage,
-		NULL TSRMLS_CC
-	);
-	object.handlers = &zend_generator_handlers;
-
-	return object;
+	return (zend_object*)generator;
 }
 /* }}} */
 
-static void copy_closure_static_var(zval **var TSRMLS_DC, int num_args, va_list args, zend_hash_key *key) /* {{{ */
+static int copy_closure_static_var(zval *var TSRMLS_DC, int num_args, va_list args, zend_hash_key *key) /* {{{ */
 {
 	HashTable *target = va_arg(args, HashTable *);
 
-	SEPARATE_ZVAL_TO_MAKE_IS_REF(var);
-	Z_ADDREF_PP(var);
-	zend_hash_quick_update(target, key->arKey, key->nKeyLength, key->h, var, sizeof(zval *), NULL);
+	ZVAL_MAKE_REF(var);
+	Z_ADDREF_P(var);
+	zend_hash_update(target, key->key, var);
+	return 0;
 }
 /* }}} */
 
-/* Requires globals EG(scope), EG(current_scope), EG(This),
- * EG(active_symbol_table) and EG(current_execute_data). */
-ZEND_API zval *zend_generator_create_zval(zend_op_array *op_array TSRMLS_DC) /* {{{ */
+/* Requires globals EG(scope), EG(This) and EG(current_execute_data). */
+ZEND_API void zend_generator_create_zval(zend_execute_data *call, zend_op_array *op_array, zval *return_value TSRMLS_DC) /* {{{ */
 {
-	zval *return_value;
 	zend_generator *generator;
 	zend_execute_data *current_execute_data;
-	zend_op **opline_ptr;
-	HashTable *current_symbol_table;
 	zend_execute_data *execute_data;
-	zend_vm_stack current_stack = EG(argument_stack);
+	zend_vm_stack current_stack = EG(vm_stack);
 
+	current_stack->top = EG(vm_stack_top);
 	/* Create a clone of closure, because it may be destroyed */
 	if (op_array->fn_flags & ZEND_ACC_CLOSURE) {
 		zend_op_array *op_array_copy = (zend_op_array*)emalloc(sizeof(zend_op_array));
@@ -264,8 +236,8 @@ ZEND_API zval *zend_generator_create_zval(zend_op_array *op_array TSRMLS_DC) /*
 			);
 			zend_hash_apply_with_arguments(
 				op_array->static_variables TSRMLS_CC,
-				(apply_func_args_t) copy_closure_static_var,
-				1, op_array_copy->static_variables
+				copy_closure_static_var, 1, 
+				op_array_copy->static_variables
 			);
 		}
 
@@ -273,41 +245,33 @@ ZEND_API zval *zend_generator_create_zval(zend_op_array *op_array TSRMLS_DC) /*
 	}
 	
 	/* Create new execution context. We have to back up and restore
-	 * EG(current_execute_data), EG(opline_ptr) and EG(active_symbol_table)
-	 * here because the function modifies or uses them  */
+	 * EG(current_execute_data) here. */
 	current_execute_data = EG(current_execute_data);
-	opline_ptr = EG(opline_ptr);
-	current_symbol_table = EG(active_symbol_table);
-	EG(active_symbol_table) = NULL;
-	execute_data = zend_create_execute_data_from_op_array(op_array, 0 TSRMLS_CC);
-	EG(active_symbol_table) = current_symbol_table;
+	execute_data = zend_create_generator_execute_data(call, op_array, return_value TSRMLS_CC);
 	EG(current_execute_data) = current_execute_data;
-	EG(opline_ptr) = opline_ptr;
 
-	ALLOC_INIT_ZVAL(return_value);
 	object_init_ex(return_value, zend_ce_generator);
 
-	if (EG(This)) {
-		Z_ADDREF_P(EG(This));
+	if (Z_OBJ(call->This)) {
+		Z_ADDREF(call->This);
 	}
 
-	/* Back up executor globals. */
-	execute_data->current_scope = EG(scope);
-	execute_data->current_called_scope = EG(called_scope);
-	execute_data->symbol_table = EG(active_symbol_table);
-	execute_data->current_this = EG(This);
-
 	/* Save execution context in generator object. */
-	generator = (zend_generator *) zend_object_store_get_object(return_value TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(return_value);
+	execute_data->prev_execute_data = NULL;
 	generator->execute_data = execute_data;
-	generator->stack = EG(argument_stack);
-	EG(argument_stack) = current_stack;
-
-	return return_value;
+	generator->stack = EG(vm_stack);
+	generator->stack->top = EG(vm_stack_top);
+	EG(vm_stack_top) = current_stack->top;
+	EG(vm_stack_end) = current_stack->end;
+	EG(vm_stack) = current_stack;
+
+	/* EX(return_value) keeps pointer to zend_object (not a real zval) */
+	execute_data->return_value = (zval*)generator;
 }
 /* }}} */
 
-static zend_function *zend_generator_get_constructor(zval *object TSRMLS_DC) /* {{{ */
+static zend_function *zend_generator_get_constructor(zend_object *object TSRMLS_DC) /* {{{ */
 {
 	zend_error(E_RECOVERABLE_ERROR, "The \"Generator\" class is reserved for internal use and cannot be manually instantiated");
 
@@ -331,53 +295,40 @@ ZEND_API void zend_generator_resume(zend_generator *generator TSRMLS_DC) /* {{{
 
 	{
 		/* Backup executor globals */
-		zval **original_return_value_ptr_ptr = EG(return_value_ptr_ptr);
 		zend_execute_data *original_execute_data = EG(current_execute_data);
-		zend_op **original_opline_ptr = EG(opline_ptr);
-		zend_op_array *original_active_op_array = EG(active_op_array);
-		HashTable *original_active_symbol_table = EG(active_symbol_table);
-		zval *original_This = EG(This);
 		zend_class_entry *original_scope = EG(scope);
-		zend_class_entry *original_called_scope = EG(called_scope);
-		zend_vm_stack original_stack = EG(argument_stack);
-
-		/* We (mis)use the return_value_ptr_ptr to provide the generator object
-		 * to the executor, so YIELD will be able to set the yielded value */
-		EG(return_value_ptr_ptr) = (zval **) generator;
+		zend_vm_stack original_stack = EG(vm_stack);
 
+		original_stack->top = EG(vm_stack_top);
 		/* Set executor globals */
 		EG(current_execute_data) = generator->execute_data;
-		EG(opline_ptr) = &generator->execute_data->opline;
-		EG(active_op_array) = generator->execute_data->op_array;
-		EG(active_symbol_table) = generator->execute_data->symbol_table;
-		EG(This) = generator->execute_data->current_this;
-		EG(scope) = generator->execute_data->current_scope;
-		EG(called_scope) = generator->execute_data->current_called_scope;
-		EG(argument_stack) = generator->stack;
+		EG(scope) = generator->execute_data->scope;
+		EG(vm_stack_top) = generator->stack->top;
+		EG(vm_stack_end) = generator->stack->end;
+		EG(vm_stack) = generator->stack;
 
 		/* We want the backtrace to look as if the generator function was
 		 * called from whatever method we are current running (e.g. next()).
-		 * The first prev_execute_data contains an additional stack frame,
-		 * which makes the generator function show up in the backtrace and
-		 * makes the arguments available to func_get_args(). So we have to
-		 * set the prev_execute_data of that prev_execute_data :) */
-		generator->execute_data->prev_execute_data->prev_execute_data = original_execute_data;
+		 * So we have to link generator call frame with caller call frames */
+
+		generator->execute_data->prev_execute_data = original_execute_data;
 
 		/* Resume execution */
 		generator->flags |= ZEND_GENERATOR_CURRENTLY_RUNNING;
 		zend_execute_ex(generator->execute_data TSRMLS_CC);
 		generator->flags &= ~ZEND_GENERATOR_CURRENTLY_RUNNING;
 
+		/* Unlink generator call_frame from the caller */
+		if (generator->execute_data) {
+			generator->execute_data->prev_execute_data = NULL;
+		}
+
 		/* Restore executor globals */
-		EG(return_value_ptr_ptr) = original_return_value_ptr_ptr;
 		EG(current_execute_data) = original_execute_data;
-		EG(opline_ptr) = original_opline_ptr;
-		EG(active_op_array) = original_active_op_array;
-		EG(active_symbol_table) = original_active_symbol_table;
-		EG(This) = original_This;
 		EG(scope) = original_scope;
-		EG(called_scope) = original_called_scope;
-		EG(argument_stack) = original_stack;
+		EG(vm_stack_top) = original_stack->top;
+		EG(vm_stack_end) = original_stack->end;
+		EG(vm_stack) = original_stack;
 
 		/* If an exception was thrown in the generator we have to internally
 		 * rethrow it in the parent scope. */
@@ -390,7 +341,7 @@ ZEND_API void zend_generator_resume(zend_generator *generator TSRMLS_DC) /* {{{
 
 static void zend_generator_ensure_initialized(zend_generator *generator TSRMLS_DC) /* {{{ */
 {
-	if (generator->execute_data && !generator->value) {
+	if (generator->execute_data && Z_TYPE(generator->value) == IS_UNDEF) {
 		zend_generator_resume(generator TSRMLS_CC);
 		generator->flags |= ZEND_GENERATOR_AT_FIRST_YIELD;
 	}
@@ -417,7 +368,7 @@ ZEND_METHOD(Generator, rewind)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_rewind(generator TSRMLS_CC);
 }
@@ -433,11 +384,11 @@ ZEND_METHOD(Generator, valid)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	RETURN_BOOL(generator->value != NULL);
+	RETURN_BOOL(Z_TYPE(generator->value) != IS_UNDEF);
 }
 /* }}} */
 
@@ -451,12 +402,12 @@ ZEND_METHOD(Generator, current)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	if (generator->value) {
-		RETURN_ZVAL_FAST(generator->value);
+	if (Z_TYPE(generator->value) != IS_UNDEF) {
+		RETURN_ZVAL_FAST(&generator->value);
 	}
 }
 /* }}} */
@@ -471,12 +422,12 @@ ZEND_METHOD(Generator, key)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	if (generator->key) {
-		RETURN_ZVAL_FAST(generator->key);
+	if (Z_TYPE(generator->key) != IS_UNDEF) {
+		RETURN_ZVAL_FAST(&generator->key);
 	}
 }
 /* }}} */
@@ -491,7 +442,7 @@ ZEND_METHOD(Generator, next)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
@@ -510,7 +461,7 @@ ZEND_METHOD(Generator, send)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC); 
 
@@ -519,13 +470,16 @@ ZEND_METHOD(Generator, send)
 		return;
 	}
 
-	/* Put sent value into the TMP_VAR slot */
-	MAKE_COPY_ZVAL(&value, &generator->send_target->tmp_var);
+	/* Put sent value in the target VAR slot, if it is used */
+	if (generator->send_target) {
+		if (Z_REFCOUNTED_P(generator->send_target)) Z_DELREF_P(generator->send_target);
+		ZVAL_COPY(generator->send_target, value);
+	}
 
 	zend_generator_resume(generator TSRMLS_CC);
 
-	if (generator->value) {
-		RETURN_ZVAL_FAST(generator->value);
+	if (Z_TYPE(generator->value) != IS_UNDEF) {
+		RETURN_ZVAL_FAST(&generator->value);
 	}
 }
 /* }}} */
@@ -534,36 +488,37 @@ ZEND_METHOD(Generator, send)
  * Throws an exception into the generator */
 ZEND_METHOD(Generator, throw)
 {
-	zval *exception, *exception_copy;
+	zval *exception, exception_copy;
 	zend_generator *generator;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &exception) == FAILURE) {
 		return;
 	}
 
-	ALLOC_ZVAL(exception_copy);
-	MAKE_COPY_ZVAL(&exception, exception_copy);
+	ZVAL_DUP(&exception_copy, exception);
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
+
+	zend_generator_ensure_initialized(generator TSRMLS_CC); 
 
 	if (generator->execute_data) {
 		/* Throw the exception in the context of the generator */
 		zend_execute_data *current_execute_data = EG(current_execute_data);
 		EG(current_execute_data) = generator->execute_data;
 
-		zend_throw_exception_object(exception_copy TSRMLS_CC);
+		zend_throw_exception_object(&exception_copy TSRMLS_CC);
 
 		EG(current_execute_data) = current_execute_data;
 
 		zend_generator_resume(generator TSRMLS_CC);
 
-		if (generator->value) {
-			RETURN_ZVAL_FAST(generator->value);
+		if (Z_TYPE(generator->value) != IS_UNDEF) {
+			RETURN_ZVAL_FAST(&generator->value);
 		}
 	} else {
 		/* If the generator is already closed throw the exception in the
 		 * current context */
-		zend_throw_exception_object(exception_copy TSRMLS_CC);
+		zend_throw_exception_object(&exception_copy TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -588,44 +543,41 @@ ZEND_METHOD(Generator, __wakeup)
 
 static void zend_generator_iterator_dtor(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
 {
-	zval *object = ((zend_generator_iterator *) iterator)->object;
-
-	zval_ptr_dtor(&object);
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
+	generator->iterator = NULL;
+	zval_ptr_dtor(&iterator->data);
+	zend_iterator_dtor(iterator TSRMLS_CC);
 }
 /* }}} */
 
 static int zend_generator_iterator_valid(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
 {
-	zend_generator *generator = (zend_generator *) iterator->data;
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	return generator->value != NULL ? SUCCESS : FAILURE;
+	return Z_TYPE(generator->value) != IS_UNDEF ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-static void zend_generator_iterator_get_data(zend_object_iterator *iterator, zval ***data TSRMLS_DC) /* {{{ */
+static zval *zend_generator_iterator_get_data(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
 {
-	zend_generator *generator = (zend_generator *) iterator->data;
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	if (generator->value) {
-		*data = &generator->value;
-	} else {
-		*data = NULL;
-	}
+	return &generator->value;
 }
 /* }}} */
 
 static void zend_generator_iterator_get_key(zend_object_iterator *iterator, zval *key TSRMLS_DC) /* {{{ */
 {
-	zend_generator *generator = (zend_generator *) iterator->data;
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	if (generator->key) {
-		ZVAL_ZVAL(key, generator->key, 1, 0);
+	if (Z_TYPE(generator->key) != IS_UNDEF) {
+		ZVAL_ZVAL(key, &generator->key, 1, 0);
 	} else {
 		ZVAL_NULL(key);
 	}
@@ -634,7 +586,7 @@ static void zend_generator_iterator_get_key(zend_object_iterator *iterator, zval
 
 static void zend_generator_iterator_move_forward(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
 {
-	zend_generator *generator = (zend_generator *) iterator->data;
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
@@ -644,7 +596,7 @@ static void zend_generator_iterator_move_forward(zend_object_iterator *iterator
 
 static void zend_generator_iterator_rewind(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
 {
-	zend_generator *generator = (zend_generator *) iterator->data;
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
 
 	zend_generator_rewind(generator TSRMLS_CC);
 }
@@ -661,31 +613,27 @@ static zend_object_iterator_funcs zend_generator_iterator_functions = {
 
 zend_object_iterator *zend_generator_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) /* {{{ */
 {
-	zend_generator_iterator *iterator;
-	zend_generator *generator;
-
-	generator = (zend_generator *) zend_object_store_get_object(object TSRMLS_CC);
+	zend_object_iterator *iterator;
+	zend_generator *generator = (zend_generator*)Z_OBJ_P(object);
 
 	if (!generator->execute_data) {
 		zend_throw_exception(NULL, "Cannot traverse an already closed generator", 0 TSRMLS_CC);
 		return NULL;
 	}
 
-	if (by_ref && !(generator->execute_data->op_array->fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
+	if (by_ref && !(generator->execute_data->func->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
 		zend_throw_exception(NULL, "You can only iterate a generator by-reference if it declared that it yields by-reference", 0 TSRMLS_CC);
 		return NULL;
 	}
 
-	iterator = &generator->iterator;
-	iterator->intern.funcs = &zend_generator_iterator_functions;
-	iterator->intern.data = (void *) generator;
+	iterator = generator->iterator = emalloc(sizeof(zend_object_iterator));
+	
+	zend_iterator_init(iterator TSRMLS_CC);
 
-	/* We have to keep a reference to the generator object zval around,
-	 * otherwise the generator may be destroyed during iteration. */
-	Z_ADDREF_P(object);
-	iterator->object = object;
+	iterator->funcs = &zend_generator_iterator_functions;
+	ZVAL_COPY(&iterator->data, object);
 
-	return (zend_object_iterator *) iterator;
+	return iterator;
 }
 /* }}} */
 
@@ -729,8 +677,10 @@ void zend_register_generator_ce(TSRMLS_D) /* {{{ */
 	zend_ce_generator->iterator_funcs.funcs = &zend_generator_iterator_functions;
 
 	memcpy(&zend_generator_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
-	zend_generator_handlers.get_constructor = zend_generator_get_constructor;
+	zend_generator_handlers.free_obj = zend_generator_free_storage;
+	zend_generator_handlers.dtor_obj = zend_generator_dtor_storage;
 	zend_generator_handlers.clone_obj = NULL;
+	zend_generator_handlers.get_constructor = zend_generator_get_constructor;
 }
 /* }}} */