1 files changed, 115 insertions, 176 deletions

diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c
index 2b4a8c9a16..922c6a3f2b 100644
--- a/Zend/zend_generators.c
+++ b/Zend/zend_generators.c
@@ -27,15 +27,15 @@
 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->op_array;
+	zend_op_array *op_array = &execute_data->func->op_array;
 
 	if (generator->send_target) {
-		Z_DELREF_PP(generator->send_target);
+		if (Z_REFCOUNTED_P(generator->send_target)) Z_DELREF_P(generator->send_target);
 		generator->send_target = NULL;
 	}
 
@@ -60,14 +60,14 @@ static void zend_generator_cleanup_unfinished_execution(zend_generator *generato
 				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);
+							zval *var = EX_VAR_2(execute_data, brk_opline->op1.var);
+							zval_ptr_dtor(var);
 						}
 						break;
 					case ZEND_FREE:
 						{
-							temp_variable *var = EX_TMP_VAR(execute_data, brk_opline->op1.var);
-							zval_dtor(&var->tmp_var);
+							zval *var = EX_VAR_2(execute_data, brk_opline->op1.var);
+							zval_dtor(var);
 						}
 						break;
 				}
@@ -75,42 +75,32 @@ static void zend_generator_cleanup_unfinished_execution(zend_generator *generato
 		}
 	}
 
-	/* Clear any backed up stack arguments */
-	{
-		void **ptr = generator->stack->top - 1;
-		void **end = zend_vm_stack_frame_base(execute_data);
-
-		for (; ptr >= end; --ptr) {
-			zval_ptr_dtor((zval **) ptr);
-		}
-	}
-
 	/* If yield was used as a function argument there may be active
 	 * method calls those objects need to be freed */
-	while (execute_data->call >= execute_data->call_slots) {
+	while (execute_data->call) {
 		if (execute_data->call->object) {
-			zval_ptr_dtor(&execute_data->call->object);
+			OBJ_RELEASE(execute_data->call->object);
 		}
-		execute_data->call--;
+		execute_data->call = execute_data->call->prev_nested_call;
 	}
 }
 /* }}} */
 
 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);
@@ -118,8 +108,8 @@ 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 (execute_data->object) {
+			OBJ_RELEASE(execute_data->object);
 		}
 
 		/* A fatal error / die occurred during the generator execution. Trying to clean
@@ -129,23 +119,7 @@ ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished
 			return;
 		}
 
-		/* 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);
-				}
-			}
-		}
+		zend_vm_stack_free_extra_args(generator->execute_data TSRMLS_CC);
 
 		/* Some cleanups are only necessary if the generator was closued
 		 * before it could finish execution (reach a return statement). */
@@ -165,24 +139,25 @@ ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished
 }
 /* }}} */
 
-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;
 	int i;
 
-	if (!ex || !ex->op_array->has_finally_block) {
+	if (!ex || !ex->func->op_array.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;
@@ -196,7 +171,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);
@@ -204,19 +179,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));
@@ -225,37 +204,28 @@ 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);
 
@@ -275,8 +245,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
 			);
 		}
 
@@ -284,41 +254,30 @@ 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(EG(This))) {
+		Z_ADDREF(EG(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;
+	/* 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");
 
@@ -342,52 +301,39 @@ 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_object *original_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;
+		original_This = Z_OBJ(EG(This));
 
 		/* 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;
+		Z_OBJ(EG(This)) = generator->execute_data->object;
+		EG(scope) = generator->execute_data->scope;
 		EG(argument_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;
+		Z_OBJ(EG(This)) = original_This;
 		EG(scope) = original_scope;
-		EG(called_scope) = original_called_scope;
 		EG(argument_stack) = original_stack;
 
 		/* If an exception was thrown in the generator we have to internally
@@ -401,7 +347,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;
 	}
@@ -428,7 +374,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);
 }
@@ -444,11 +390,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);
 }
 /* }}} */
 
@@ -462,12 +408,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);
 	}
 }
 /* }}} */
@@ -482,12 +428,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);
 	}
 }
 /* }}} */
@@ -502,7 +448,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);
 
@@ -521,7 +467,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); 
 
@@ -532,15 +478,14 @@ ZEND_METHOD(Generator, send)
 
 	/* Put sent value in the target VAR slot, if it is used */
 	if (generator->send_target) {
-		Z_DELREF_PP(generator->send_target);
-		Z_ADDREF_P(value);
-		*generator->send_target = value;
+		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);
 	}
 }
 /* }}} */
@@ -549,17 +494,16 @@ 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); 
 
@@ -568,19 +512,19 @@ ZEND_METHOD(Generator, throw)
 		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);
 	}
 }
 /* }}} */
@@ -605,44 +549,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);
 	}
@@ -651,7 +592,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);
 
@@ -661,7 +602,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);
 }
@@ -678,31 +619,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;
 }
 /* }}} */
 
@@ -746,8 +683,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;
 }
 /* }}} */