clones/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-09-21 18:07:23 +00:00
Code Issues Packages Projects Releases Wiki Activity
24f1ef1b02
php-src/Zend/zend_generators.c

833 lines
26 KiB
C
Raw Normal View History

Add empty Generator class
2012-05-19 22:03:27 +00:00
/*
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
| Copyright (c) 1998-2012 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 |
| available through the world-wide-web at the following url: |
| http://www.zend.com/license/2_00.txt. |
| If you did not receive a copy of the Zend license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@zend.com so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Nikita Popov <nikic@php.net> |
+----------------------------------------------------------------------+
*/
/* $Id$ */
#include "zend.h"
#include "zend_API.h"
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
#include "zend_interfaces.h"
Fix throwing of exceptions within a generator If a generator threw an exception and was iterated using foreach (i.e. not manually) an infinite loop was triggered. The reason was that the exception was not properly rethrown using zend_throw_exception_internal.
2012-07-22 15:46:46 +00:00
#include "zend_exceptions.h"
Add empty Generator class
2012-05-19 22:03:27 +00:00
#include "zend_generators.h"
ZEND_API zend_class_entry *zend_ce_generator;
Add some boilerplate code for Generator class The Generator class now uses a zend_generator struct, so it'll be able to store additional info. This commit also ensures that Generator cannot be directly instantiated and extended. The error tests are now in a separate folder from the (yet-to-come) functional tests.
2012-05-20 12:19:16 +00:00
static zend_object_handlers zend_generator_handlers;
- generators API exported for extensions - improved RETURN sequence to avoid redundant check if op_array is a generator
2012-12-11 13:25:32 +00:00
ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished_execution TSRMLS_DC) /* {{{ */
Add some boilerplate code for Generator class The Generator class now uses a zend_generator struct, so it'll be able to store additional info. This commit also ensures that Generator cannot be directly instantiated and extended. The error tests are now in a separate folder from the (yet-to-come) functional tests.
2012-05-20 12:19:16 +00:00
{
Fix crash when last yielded value is a closure If zend_generator_close is called from within zend_generator_resume (e.g. due to a return statement) then all the EGs will still be using the values from the generator. That's why the stack frame has to be the last thing that is dtored, otherwise some other dtor that is using EG(current_execute_data) might access the already freed memory segment. This was the case with the closure dtor. The fix is to move the dtors for key and value to the start of the handler. This way the stack frame is the last thing that is freed.
2012-12-21 16:28:20 +00:00
if (generator->value) {
zval_ptr_dtor(&generator->value);
generator->value = NULL;
}
if (generator->key) {
zval_ptr_dtor(&generator->key);
generator->key = NULL;
}
Add initial code for suspending execution This is just some initial code, which is still quite broken (and needs to be moved so it can be reused.)
2012-05-23 12:20:25 +00:00
if (generator->execute_data) {
zend_execute_data *execute_data = generator->execute_data;
Fix several issues and allow rewind only at/before first yield * Trying to resume a generator while it is already running now throws a fatal error. * Trying to use yield in finally while the generator is being force-closed (by GC) throws a fatal error. * Rewinding after the first yield now throws an Exception
2012-08-25 15:40:08 +00:00
zend_op_array *op_array = execute_data->op_array;
Restored proper generators behaviour in conjunction with "finally". (Nikita)
2012-12-12 13:47:55 +00:00
if (!finished_execution) {
if (op_array->has_finally_block) {
/* -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;
zend_uint finally_op_num = 0;
/* Find next finally block */
int i;
for (i = 0; i < op_array->last_try_catch; i++) {
zend_try_catch_element *try_catch = &op_array->try_catch_array[i];
if (op_num < try_catch->try_op) {
break;
}
if (op_num < try_catch->finally_op) {
finally_op_num = try_catch->finally_op;
}
}
/* If a finally block was found we jump directly to it and
* resume the generator. Furthermore we abort this close call
* because the generator will already be closed somewhere in
* the resume. */
if (finally_op_num) {
execute_data->opline = &op_array->opcodes[finally_op_num];
execute_data->fast_ret = NULL;
generator->flags |= ZEND_GENERATOR_FORCED_CLOSE;
zend_generator_resume(generator TSRMLS_CC);
return;
}
}
}
Run finally if generator is closed before finishing
2012-08-24 13:50:53 +00:00
Add initial code for suspending execution This is just some initial code, which is still quite broken (and needs to be moved so it can be reused.)
2012-05-23 12:20:25 +00:00
if (!execute_data->symbol_table) {
Optimized access to temporary and compiled VM variables
2012-12-04 06:14:39 +00:00
zend_free_compiled_variables(execute_data);
Add initial code for suspending execution This is just some initial code, which is still quite broken (and needs to be moved so it can be reused.)
2012-05-23 12:20:25 +00:00
} else {
Fix thread safe build
2012-06-20 19:31:23 +00:00
zend_clean_and_cache_symbol_table(execute_data->symbol_table TSRMLS_CC);
Add initial code for suspending execution This is just some initial code, which is still quite broken (and needs to be moved so it can be reused.)
2012-05-23 12:20:25 +00:00
}
Add support for generator methods
2012-05-27 01:50:31 +00:00
if (execute_data->current_this) {
zval_ptr_dtor(&execute_data->current_this);
}
Free loop variables If the generator is closed before it has finished running, it may happen that some FREE or SWITCH_FREE opcodes haven't been executed and memory is leaked. This fixes it by walking the brk_cont_array and manually freeing the variables.
2012-05-27 15:14:20 +00:00
/* 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) {
Fix several issues and allow rewind only at/before first yield * Trying to resume a generator while it is already running now throws a fatal error. * Trying to use yield in finally while the generator is being force-closed (by GC) throws a fatal error. * Rewinding after the first yield now throws an Exception
2012-08-25 15:40:08 +00:00
/* -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;
Free loop variables If the generator is closed before it has finished running, it may happen that some FREE or SWITCH_FREE opcodes haven't been executed and memory is leaked. This fixes it by walking the brk_cont_array and manually freeing the variables.
2012-05-27 15:14:20 +00:00
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:
{
Optimized access to temporary and compiled VM variables
2012-12-04 06:14:39 +00:00
temp_variable *var = EX_TMP_VAR(execute_data, brk_opline->op1.var);
Free loop variables If the generator is closed before it has finished running, it may happen that some FREE or SWITCH_FREE opcodes haven't been executed and memory is leaked. This fixes it by walking the brk_cont_array and manually freeing the variables.
2012-05-27 15:14:20 +00:00
zval_ptr_dtor(&var->var.ptr);
}
break;
case ZEND_FREE:
{
Optimized access to temporary and compiled VM variables
2012-12-04 06:14:39 +00:00
temp_variable *var = EX_TMP_VAR(execute_data, brk_opline->op1.var);
Free loop variables If the generator is closed before it has finished running, it may happen that some FREE or SWITCH_FREE opcodes haven't been executed and memory is leaked. This fixes it by walking the brk_cont_array and manually freeing the variables.
2012-05-27 15:14:20 +00:00
zval_dtor(&var->tmp_var);
}
break;
}
}
}
}
Allow yielding during function calls During function calls arguments are pushed onto the stack. Now these are backed up on yield and restored on resume. This requires memcpy'ing them, but there doesn't seem to be any better way to do it. Also this fixes the issue with exceptions thrown during function calls.
2012-05-30 22:00:30 +00:00
/* Clear any backed up stack arguments */
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
if (generator->stack != EG(argument_stack)) {
Restored proper generators behaviour in conjunction with "finally". (Nikita)
2012-12-12 13:47:55 +00:00
void **stack_frame = zend_vm_stack_frame_base(execute_data);
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
while (generator->stack->top != stack_frame) {
zval_ptr_dtor((zval**)stack_frame);
stack_frame++;
Allow yielding during function calls During function calls arguments are pushed onto the stack. Now these are backed up on yield and restored on resume. This requires memcpy'ing them, but there doesn't seem to be any better way to do it. Also this fixes the issue with exceptions thrown during function calls.
2012-05-30 22:00:30 +00:00
}
}
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
while (execute_data->call >= execute_data->call_slots) {
if (execute_data->call->object) {
zval_ptr_dtor(&execute_data->call->object);
Fixed bug #63132 EG(arg_types_stack) is now also backed up when generators are used. This allows the use of yield in nested method calls. This commit adds two new functions to the zend_ptr_stack API: zend_ptr_stack_push_from_memory zend_ptr_stack_pop_into_memory both taking the following arguments: zend_ptr_stack *stack, int count, void **pointers
2012-09-22 17:12:21 +00:00
}
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
execute_data->call--;
}
Fixed bug #63132 EG(arg_types_stack) is now also backed up when generators are used. This allows the use of yield in nested method calls. This commit adds two new functions to the zend_ptr_stack API: zend_ptr_stack_push_from_memory zend_ptr_stack_pop_into_memory both taking the following arguments: zend_ptr_stack *stack, int count, void **pointers
2012-09-22 17:12:21 +00:00
Fix backtraces and func_get_args() To make the generator function show up in backtraces one has to insert an additional execute_data into the chain, as prev_execute_data->function_state is used to determine the called function. Adding the additional stack frame is also required for func_get_args(), as the arguments are fetched from there too. The arguments have to be copied in order to keep them around. Due to the way they are saved doing so is quite ugly, so I added another function zend_copy_arguments to zend_execute.c which handles this.
2012-06-08 22:40:47 +00:00
/* 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);
}
}
}
Fixed bug #62991 (Segfault with generator and closure)
2012-09-05 05:50:55 +00:00
/* Free a clone of closure */
if (op_array->fn_flags & ZEND_ACC_CLOSURE) {
destroy_op_array(op_array TSRMLS_CC);
efree(op_array);
}
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
efree(generator->stack);
if (generator->stack == EG(argument_stack)) {
/* abnormal exit for running generator */
EG(argument_stack) = NULL;
}
Close generator on return
2012-05-26 21:59:22 +00:00
generator->execute_data = NULL;
Add initial code for suspending execution This is just some initial code, which is still quite broken (and needs to be moved so it can be reused.)
2012-05-23 12:20:25 +00:00
}
Close generator on return
2012-05-26 21:59:22 +00:00
}
/* }}} */
static void zend_generator_free_storage(zend_generator *generator TSRMLS_DC) /* {{{ */
{
Free loop variables If the generator is closed before it has finished running, it may happen that some FREE or SWITCH_FREE opcodes haven't been executed and memory is leaked. This fixes it by walking the brk_cont_array and manually freeing the variables.
2012-05-27 15:14:20 +00:00
zend_generator_close(generator, 0 TSRMLS_CC);
Close generator on return
2012-05-26 21:59:22 +00:00
zend_object_std_dtor(&generator->std TSRMLS_CC);
Add some boilerplate code for Generator class The Generator class now uses a zend_generator struct, so it'll be able to store additional info. This commit also ensures that Generator cannot be directly instantiated and extended. The error tests are now in a separate folder from the (yet-to-come) functional tests.
2012-05-20 12:19:16 +00:00
efree(generator);
}
/* }}} */
- Fixed ZTS build
2012-11-30 11:07:35 +00:00
static void zend_generator_clone_storage(zend_generator *orig, zend_generator **clone_ptr TSRMLS_DC) /* {{{ */
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
{
zend_generator *clone = emalloc(sizeof(zend_generator));
memcpy(clone, orig, sizeof(zend_generator));
if (orig->execute_data) {
/* Create a few shorter aliases to the old execution data */
zend_execute_data *execute_data = orig->execute_data;
zend_op_array *op_array = execute_data->op_array;
HashTable *symbol_table = execute_data->symbol_table;
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
zend_execute_data *current_execute_data;
zend_op **opline_ptr;
HashTable *current_symbol_table;
zend_vm_stack current_stack;
zval *current_this;
void **stack_frame, **orig_stack_frame;
/* Create new execution context. We have to back up and restore
* EG(current_execute_data), EG(opline_ptr), EG(active_symbol_table)
* and EG(This) here because the function modifies or uses them */
current_execute_data = EG(current_execute_data);
EG(current_execute_data) = execute_data->prev_execute_data;
opline_ptr = EG(opline_ptr);
current_symbol_table = EG(active_symbol_table);
EG(active_symbol_table) = execute_data->symbol_table;
current_this = EG(This);
EG(This) = NULL;
current_stack = EG(argument_stack);
clone->execute_data = zend_create_execute_data_from_op_array(op_array, 0 TSRMLS_CC);
clone->stack = EG(argument_stack);
EG(argument_stack) = current_stack;
EG(This) = current_this;
EG(active_symbol_table) = current_symbol_table;
EG(current_execute_data) = current_execute_data;
EG(opline_ptr) = opline_ptr;
/* copy */
clone->execute_data->opline = execute_data->opline;
clone->execute_data->function_state = execute_data->function_state;
Do not add a ref to EX(object) on generator clone If a ref has to be added it will be already added while walking the call slots.
2012-12-20 19:33:18 +00:00
clone->execute_data->object = execute_data->object;
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
clone->execute_data->current_scope = execute_data->current_scope;
clone->execute_data->current_called_scope = execute_data->current_called_scope;
clone->execute_data->fast_ret = execute_data->fast_ret;
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
if (!symbol_table) {
int i;
/* Copy compiled variables */
for (i = 0; i < op_array->last_var; i++) {
Optimized access to temporary and compiled VM variables
2012-12-04 06:14:39 +00:00
if (*EX_CV_NUM(execute_data, i)) {
*EX_CV_NUM(clone->execute_data, i) = (zval **) EX_CV_NUM(clone->execute_data, op_array->last_var + i);
**EX_CV_NUM(clone->execute_data, i) = *(zval **) EX_CV_NUM(execute_data, op_array->last_var + i);
Z_ADDREF_PP(*EX_CV_NUM(clone->execute_data, i));
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
}
}
} else {
/* Copy symbol table */
ALLOC_HASHTABLE(clone->execute_data->symbol_table);
zend_hash_init(clone->execute_data->symbol_table, zend_hash_num_elements(symbol_table), NULL, ZVAL_PTR_DTOR, 0);
zend_hash_copy(clone->execute_data->symbol_table, symbol_table, (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *));
/* Update zval** pointers for compiled variables */
{
int i;
for (i = 0; i < op_array->last_var; i++) {
Optimized access to temporary and compiled VM variables
2012-12-04 06:14:39 +00:00
if (zend_hash_quick_find(clone->execute_data->symbol_table, op_array->vars[i].name, op_array->vars[i].name_len + 1, op_array->vars[i].hash_value, (void **) EX_CV_NUM(clone->execute_data, i)) == FAILURE) {
*EX_CV_NUM(clone->execute_data, i) = NULL;
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
}
}
}
}
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
/* Copy nested-calls stack */
if (execute_data->call) {
clone->execute_data->call = clone->execute_data->call_slots +
(execute_data->call - execute_data->call_slots);
} else {
clone->execute_data->call = NULL;
}
Optimized access to temporary and compiled VM variables
2012-12-04 06:14:39 +00:00
memcpy(clone->execute_data->call_slots, execute_data->call_slots, ZEND_MM_ALIGNED_SIZE(sizeof(call_slot)) * op_array->nested_calls);
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
if (clone->execute_data->call >= clone->execute_data->call_slots) {
call_slot *call = clone->execute_data->call;
while (call >= clone->execute_data->call_slots) {
if (call->object) {
Z_ADDREF_P(call->object);
}
call--;
}
}
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
/* Copy the temporary variables */
Optimized access to temporary and compiled VM variables
2012-12-04 06:14:39 +00:00
memcpy(EX_TMP_VAR_NUM(clone->execute_data, op_array->T-1), EX_TMP_VAR_NUM(execute_data, op_array->T-1), ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T);
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
/* Copy arguments passed on stack */
stack_frame = zend_vm_stack_frame_base(clone->execute_data);
orig_stack_frame = zend_vm_stack_frame_base(execute_data);
clone->stack->top = stack_frame + (orig->stack->top - orig_stack_frame);
if (clone->stack->top != stack_frame) {
Optimized access to temporary and compiled VM variables
2012-12-04 06:14:39 +00:00
memcpy(stack_frame, orig_stack_frame, ZEND_MM_ALIGNED_SIZE(sizeof(zval*)) * (orig->stack->top - orig_stack_frame));
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
while (clone->stack->top != stack_frame) {
Z_ADDREF_PP((zval**)stack_frame);
stack_frame++;
}
}
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
/* Add references to loop variables */
{
zend_uint op_num = execute_data->opline - op_array->opcodes;
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;
if (brk_opline->opcode == ZEND_SWITCH_FREE) {
Optimized access to temporary and compiled VM variables
2012-12-04 06:14:39 +00:00
temp_variable *var = EX_TMP_VAR(execute_data, brk_opline->op1.var);
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
Z_ADDREF_P(var->var.ptr);
}
}
}
}
/* Update the send_target to use the temporary variable with the same
Add sceleton for yield* expression This does not yet actually implement any delegation.
2012-06-11 21:59:46 +00:00
* offset as the original generator, but in our temporary variable
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
* memory segment. */
if (orig->send_target) {
Optimized access to temporary and compiled VM variables
2012-12-04 06:14:39 +00:00
size_t offset = (char *) orig->send_target - (char *)execute_data;
clone->send_target = EX_TMP_VAR(clone->execute_data, offset);
Fix leak when generator ignores sent value When the return value of yield wasn't used it was leaked. This is fixed by using a TMP_VAR return value instead of VAR. TMP_VARs are automatically freed when they aren't used.
2012-12-18 20:36:48 +00:00
zval_copy_ctor(&clone->send_target->tmp_var);
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
}
Properly handle yield during method calls
2012-06-03 00:16:29 +00:00
Fix cloning of generator methods Forgot to add a reference to the this variable
2012-06-03 00:40:03 +00:00
if (execute_data->current_this) {
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
clone->execute_data->current_this = execute_data->current_this;
Fix cloning of generator methods Forgot to add a reference to the this variable
2012-06-03 00:40:03 +00:00
Z_ADDREF_P(execute_data->current_this);
}
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
}
/* The value and key are known not to be references, so simply add refs */
if (orig->value) {
Z_ADDREF_P(orig->value);
}
if (orig->key) {
Z_ADDREF_P(orig->key);
}
*clone_ptr = clone;
}
/* }}} */
Add some boilerplate code for Generator class The Generator class now uses a zend_generator struct, so it'll be able to store additional info. This commit also ensures that Generator cannot be directly instantiated and extended. The error tests are now in a separate folder from the (yet-to-come) functional tests.
2012-05-20 12:19:16 +00:00
static zend_object_value 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));
Add auto-increment keys When no key is explicitely yielded PHP will used auto-incrementing keys as a fallback. They behave the same as with arrays, i.e. the key is the successor of the largest previously used integer key.
2012-05-30 03:05:49 +00:00
/* The key will be incremented on first use, so it'll start at 0 */
generator->largest_used_integer_key = -1;
Add some boilerplate code for Generator class The Generator class now uses a zend_generator struct, so it'll be able to store additional info. This commit also ensures that Generator cannot be directly instantiated and extended. The error tests are now in a separate folder from the (yet-to-come) functional tests.
2012-05-20 12:19:16 +00:00
zend_object_std_init(&generator->std, class_type TSRMLS_CC);
object.handle = zend_objects_store_put(generator, NULL,
(zend_objects_free_object_storage_t) zend_generator_free_storage,
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
(zend_objects_store_clone_t) zend_generator_clone_storage
Add some boilerplate code for Generator class The Generator class now uses a zend_generator struct, so it'll be able to store additional info. This commit also ensures that Generator cannot be directly instantiated and extended. The error tests are now in a separate folder from the (yet-to-come) functional tests.
2012-05-20 12:19:16 +00:00
TSRMLS_CC
);
object.handlers = &zend_generator_handlers;
return object;
}
/* }}} */
Remove asterix modifier (*) for generators Generators are now automatically detected by the presence of a `yield` expression in their body. This removes the ZEND_SUSPEND_AND_RETURN_GENERATOR opcode. Instead additional checks for ZEND_ACC_GENERATOR are added to the fcall_common helper and zend_call_function. This also adds a new function zend_generator_create_zval, which handles the actual creation of the generator zval from an op array. I feel like I should deglobalize the zend_create_execute_data_from_op_array code a bit. It currently changes EG(current_execute_data) and EG(opline_ptr) which is somewhat confusing (given the name).
2012-07-19 22:49:50 +00:00
/* Requires globals EG(scope), EG(current_scope), EG(This),
* EG(active_symbol_table) and EG(current_execute_data). */
- generators API exported for extensions - improved RETURN sequence to avoid redundant check if op_array is a generator
2012-12-11 13:25:32 +00:00
ZEND_API zval *zend_generator_create_zval(zend_op_array *op_array TSRMLS_DC) /* {{{ */
Remove asterix modifier (*) for generators Generators are now automatically detected by the presence of a `yield` expression in their body. This removes the ZEND_SUSPEND_AND_RETURN_GENERATOR opcode. Instead additional checks for ZEND_ACC_GENERATOR are added to the fcall_common helper and zend_call_function. This also adds a new function zend_generator_create_zval, which handles the actual creation of the generator zval from an op array. I feel like I should deglobalize the zend_create_execute_data_from_op_array code a bit. It currently changes EG(current_execute_data) and EG(opline_ptr) which is somewhat confusing (given the name).
2012-07-19 22:49:50 +00:00
{
zval *return_value;
zend_generator *generator;
- fix build, declarations must be 1st in a contextgit checkout -f master
2012-09-05 10:53:29 +00:00
zend_execute_data *current_execute_data;
zend_op **opline_ptr;
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
HashTable *current_symbol_table;
- fix build, declarations must be 1st in a contextgit checkout -f master
2012-09-05 10:53:29 +00:00
zend_execute_data *execute_data;
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
zend_vm_stack current_stack = EG(argument_stack);
Remove asterix modifier (*) for generators Generators are now automatically detected by the presence of a `yield` expression in their body. This removes the ZEND_SUSPEND_AND_RETURN_GENERATOR opcode. Instead additional checks for ZEND_ACC_GENERATOR are added to the fcall_common helper and zend_call_function. This also adds a new function zend_generator_create_zval, which handles the actual creation of the generator zval from an op array. I feel like I should deglobalize the zend_create_execute_data_from_op_array code a bit. It currently changes EG(current_execute_data) and EG(opline_ptr) which is somewhat confusing (given the name).
2012-07-19 22:49:50 +00:00
Fixed bug #62991 (Segfault with generator and closure)
2012-09-05 05:50:55 +00:00
/* 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));
*op_array_copy = *op_array;
Fix two op_array -> function cast warnings
2012-09-16 20:01:07 +00:00
function_add_ref((zend_function *) op_array_copy);
Fixed bug #62991 (Segfault with generator and closure)
2012-09-05 05:50:55 +00:00
op_array = op_array_copy;
}
Remove asterix modifier (*) for generators Generators are now automatically detected by the presence of a `yield` expression in their body. This removes the ZEND_SUSPEND_AND_RETURN_GENERATOR opcode. Instead additional checks for ZEND_ACC_GENERATOR are added to the fcall_common helper and zend_call_function. This also adds a new function zend_generator_create_zval, which handles the actual creation of the generator zval from an op array. I feel like I should deglobalize the zend_create_execute_data_from_op_array code a bit. It currently changes EG(current_execute_data) and EG(opline_ptr) which is somewhat confusing (given the name).
2012-07-19 22:49:50 +00:00
/* Create new execution context. We have to back up and restore
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
* EG(current_execute_data), EG(opline_ptr) and EG(active_symbol_table)
* here because the function modifies or uses them */
- fix build, declarations must be 1st in a contextgit checkout -f master
2012-09-05 10:53:29 +00:00
current_execute_data = EG(current_execute_data);
opline_ptr = EG(opline_ptr);
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
current_symbol_table = EG(active_symbol_table);
EG(active_symbol_table) = NULL;
- fix build, declarations must be 1st in a contextgit checkout -f master
2012-09-05 10:53:29 +00:00
execute_data = zend_create_execute_data_from_op_array(op_array, 0 TSRMLS_CC);
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
EG(active_symbol_table) = current_symbol_table;
Remove asterix modifier (*) for generators Generators are now automatically detected by the presence of a `yield` expression in their body. This removes the ZEND_SUSPEND_AND_RETURN_GENERATOR opcode. Instead additional checks for ZEND_ACC_GENERATOR are added to the fcall_common helper and zend_call_function. This also adds a new function zend_generator_create_zval, which handles the actual creation of the generator zval from an op array. I feel like I should deglobalize the zend_create_execute_data_from_op_array code a bit. It currently changes EG(current_execute_data) and EG(opline_ptr) which is somewhat confusing (given the name).
2012-07-19 22:49:50 +00:00
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));
}
/* 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->execute_data = execute_data;
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
generator->stack = EG(argument_stack);
EG(argument_stack) = current_stack;
Remove asterix modifier (*) for generators Generators are now automatically detected by the presence of a `yield` expression in their body. This removes the ZEND_SUSPEND_AND_RETURN_GENERATOR opcode. Instead additional checks for ZEND_ACC_GENERATOR are added to the fcall_common helper and zend_call_function. This also adds a new function zend_generator_create_zval, which handles the actual creation of the generator zval from an op array. I feel like I should deglobalize the zend_create_execute_data_from_op_array code a bit. It currently changes EG(current_execute_data) and EG(opline_ptr) which is somewhat confusing (given the name).
2012-07-19 22:49:50 +00:00
return return_value;
}
/* }}} */
Add some boilerplate code for Generator class The Generator class now uses a zend_generator struct, so it'll be able to store additional info. This commit also ensures that Generator cannot be directly instantiated and extended. The error tests are now in a separate folder from the (yet-to-come) functional tests.
2012-05-20 12:19:16 +00:00
static zend_function *zend_generator_get_constructor(zval *object TSRMLS_DC) /* {{{ */
{
zend_error(E_RECOVERABLE_ERROR, "The \"Generator\" class is reserved for internal use and cannot be manually instantiated");
return NULL;
}
/* }}} */
Add empty Generator class
2012-05-19 22:03:27 +00:00
- generators API exported for extensions - improved RETURN sequence to avoid redundant check if op_array is a generator
2012-12-11 13:25:32 +00:00
ZEND_API void zend_generator_resume(zend_generator *generator TSRMLS_DC) /* {{{ */
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
{
Fixed bug #63428 (The behavior of execute() changed)
2012-11-04 04:48:35 +00:00
if (EG(exception)) {
return;
}
Close generator on return
2012-05-26 21:59:22 +00:00
/* The generator is already closed, thus can't resume */
if (!generator->execute_data) {
return;
}
Fix several issues and allow rewind only at/before first yield * Trying to resume a generator while it is already running now throws a fatal error. * Trying to use yield in finally while the generator is being force-closed (by GC) throws a fatal error. * Rewinding after the first yield now throws an Exception
2012-08-25 15:40:08 +00:00
if (generator->flags & ZEND_GENERATOR_CURRENTLY_RUNNING) {
zend_error(E_ERROR, "Cannot resume an already running generator");
}
/* Drop the AT_FIRST_YIELD flag */
generator->flags &= ~ZEND_GENERATOR_AT_FIRST_YIELD;
Add support for generator methods
2012-05-27 01:50:31 +00:00
{
/* Backup executor globals */
zval **original_return_value_ptr_ptr = EG(return_value_ptr_ptr);
Set EG(current_execute_data) This fixes several issues. In particular it makes method generators work properly and also allows generators using a symbol table.
2012-05-27 22:24:58 +00:00
zend_execute_data *original_execute_data = EG(current_execute_data);
Add support for generator methods
2012-05-27 01:50:31 +00:00
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);
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
zend_vm_stack original_stack = EG(argument_stack);
Fixed bug #63132 EG(arg_types_stack) is now also backed up when generators are used. This allows the use of yield in nested method calls. This commit adds two new functions to the zend_ptr_stack API: zend_ptr_stack_push_from_memory zend_ptr_stack_pop_into_memory both taking the following arguments: zend_ptr_stack *stack, int count, void **pointers
2012-09-22 17:12:21 +00:00
Add support for generator methods
2012-05-27 01:50:31 +00:00
/* 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 */
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
EG(return_value_ptr_ptr) = (zval **) generator;
Add support for generator methods
2012-05-27 01:50:31 +00:00
/* Set executor globals */
Set EG(current_execute_data) This fixes several issues. In particular it makes method generators work properly and also allows generators using a symbol table.
2012-05-27 22:24:58 +00:00
EG(current_execute_data) = generator->execute_data;
Add support for generator methods
2012-05-27 01:50:31 +00:00
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;
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
EG(argument_stack) = generator->stack;
Add support for generator methods
2012-05-27 01:50:31 +00:00
Fix backtraces and func_get_args() To make the generator function show up in backtraces one has to insert an additional execute_data into the chain, as prev_execute_data->function_state is used to determine the called function. Adding the additional stack frame is also required for func_get_args(), as the arguments are fetched from there too. The arguments have to be copied in order to keep them around. Due to the way they are saved doing so is quite ugly, so I added another function zend_copy_arguments to zend_execute.c which handles this.
2012-06-08 22:40:47 +00:00
/* 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;
Improve backtraces from generators The current situation is still not perfect, as the generator function itself does not appear in the stack trace. This makes sense in some way, but it would probably be more helpful if it would show up (with the bound arguments) after the $generator->xyz() call. This could be misleading too though as the function is not *really* called there.
2012-06-03 00:00:11 +00:00
Add support for generator methods
2012-05-27 01:50:31 +00:00
/* Resume execution */
Fix several issues and allow rewind only at/before first yield * Trying to resume a generator while it is already running now throws a fatal error. * Trying to use yield in finally while the generator is being force-closed (by GC) throws a fatal error. * Rewinding after the first yield now throws an Exception
2012-08-25 15:40:08 +00:00
generator->flags |= ZEND_GENERATOR_CURRENTLY_RUNNING;
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
zend_execute_ex(generator->execute_data TSRMLS_CC);
Fix several issues and allow rewind only at/before first yield * Trying to resume a generator while it is already running now throws a fatal error. * Trying to use yield in finally while the generator is being force-closed (by GC) throws a fatal error. * Rewinding after the first yield now throws an Exception
2012-08-25 15:40:08 +00:00
generator->flags &= ~ZEND_GENERATOR_CURRENTLY_RUNNING;
Add support for generator methods
2012-05-27 01:50:31 +00:00
/* Restore executor globals */
EG(return_value_ptr_ptr) = original_return_value_ptr_ptr;
Set EG(current_execute_data) This fixes several issues. In particular it makes method generators work properly and also allows generators using a symbol table.
2012-05-27 22:24:58 +00:00
EG(current_execute_data) = original_execute_data;
Add support for generator methods
2012-05-27 01:50:31 +00:00
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;
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
EG(argument_stack) = original_stack;
Fixed bug #63132 EG(arg_types_stack) is now also backed up when generators are used. This allows the use of yield in nested method calls. This commit adds two new functions to the zend_ptr_stack API: zend_ptr_stack_push_from_memory zend_ptr_stack_pop_into_memory both taking the following arguments: zend_ptr_stack *stack, int count, void **pointers
2012-09-22 17:12:21 +00:00
Fix throwing of exceptions within a generator If a generator threw an exception and was iterated using foreach (i.e. not manually) an infinite loop was triggered. The reason was that the exception was not properly rethrown using zend_throw_exception_internal.
2012-07-22 15:46:46 +00:00
/* If an exception was thrown in the generator we have to internally
* rethrow it in the parent scope. */
if (UNEXPECTED(EG(exception) != NULL)) {
zend_throw_exception_internal(NULL TSRMLS_CC);
}
Add support for generator methods
2012-05-27 01:50:31 +00:00
}
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
}
/* }}} */
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
static void zend_generator_ensure_initialized(zend_generator *generator TSRMLS_DC) /* {{{ */
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
{
Make sure that exception is thrown on rewind() after closing too
2012-08-29 18:31:34 +00:00
if (generator->execute_data && !generator->value) {
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_resume(generator TSRMLS_CC);
Fix several issues and allow rewind only at/before first yield * Trying to resume a generator while it is already running now throws a fatal error. * Trying to use yield in finally while the generator is being force-closed (by GC) throws a fatal error. * Rewinding after the first yield now throws an Exception
2012-08-25 15:40:08 +00:00
generator->flags |= ZEND_GENERATOR_AT_FIRST_YIELD;
}
}
/* }}} */
static void zend_generator_rewind(zend_generator *generator TSRMLS_DC) /* {{{ */
{
zend_generator_ensure_initialized(generator TSRMLS_CC);
if (!(generator->flags & ZEND_GENERATOR_AT_FIRST_YIELD)) {
zend_throw_exception(NULL, "Cannot rewind a generator that was already run", 0 TSRMLS_CC);
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
}
}
/* }}} */
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
/* {{{ proto void Generator::rewind()
* Rewind the generator */
ZEND_METHOD(Generator, rewind)
{
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
zend_generator *generator;
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
if (zend_parse_parameters_none() == FAILURE) {
return;
}
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
Fix several issues and allow rewind only at/before first yield * Trying to resume a generator while it is already running now throws a fatal error. * Trying to use yield in finally while the generator is being force-closed (by GC) throws a fatal error. * Rewinding after the first yield now throws an Exception
2012-08-25 15:40:08 +00:00
zend_generator_rewind(generator TSRMLS_CC);
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
}
/* }}} */
/* {{{ proto bool Generator::valid()
* Check whether the generator is valid */
ZEND_METHOD(Generator, valid)
{
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
zend_generator *generator;
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
if (zend_parse_parameters_none() == FAILURE) {
return;
}
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_ensure_initialized(generator TSRMLS_CC);
Implement return for generators For generators ZEND_RETURN directly calls ZEND_VM_RETURN(), thus passing execution back to the caller (zend_generator_resume). This commit also adds a check that only return; is used in generators and not return $value;.
2012-05-26 21:07:05 +00:00
RETURN_BOOL(generator->value != NULL);
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
}
/* }}} */
/* {{{ proto mixed Generator::current()
* Get the current value */
ZEND_METHOD(Generator, current)
{
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
zend_generator *generator;
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
if (zend_parse_parameters_none() == FAILURE) {
return;
}
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_ensure_initialized(generator TSRMLS_CC);
Implement return for generators For generators ZEND_RETURN directly calls ZEND_VM_RETURN(), thus passing execution back to the caller (zend_generator_resume). This commit also adds a check that only return; is used in generators and not return $value;.
2012-05-26 21:07:05 +00:00
if (generator->value) {
Remove wrong dtor call
2012-05-26 22:25:12 +00:00
RETURN_ZVAL(generator->value, 1, 0);
Implement return for generators For generators ZEND_RETURN directly calls ZEND_VM_RETURN(), thus passing execution back to the caller (zend_generator_resume). This commit also adds a check that only return; is used in generators and not return $value;.
2012-05-26 21:07:05 +00:00
}
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
}
/* }}} */
/* {{{ proto mixed Generator::key()
* Get the current key */
ZEND_METHOD(Generator, key)
{
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
zend_generator *generator;
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
if (zend_parse_parameters_none() == FAILURE) {
return;
}
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_ensure_initialized(generator TSRMLS_CC);
Add support for yielding keys Keys are yielded using the yield $key => $value syntax. Currently this is implemented as a statement only and not as an expression, because conflicts arise considering nesting and use in arrays: yield yield $a => $b; // could be either yield (yield $a) => $b; // or yield (yield $a => $b); Once I find some way to resolve these conflicts this should be available as an expression too. Also the key yielding code is rather copy-and-past-y for the value yielding code, so that should be factored out.
2012-05-30 00:44:06 +00:00
if (generator->key) {
RETURN_ZVAL(generator->key, 1, 0);
}
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
}
/* }}} */
/* {{{ proto void Generator::next()
* Advances the generator */
ZEND_METHOD(Generator, next)
{
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
zend_generator *generator;
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
if (zend_parse_parameters_none() == FAILURE) {
return;
}
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
Add support for executing a zend_execute_data This adds another function execute_ex(), which accepts a zend_execute_data struct to run (contrary to execute(), which accepts a zend_op_array from which it initialized the execute_data). This needs a bit more cleanup.
2012-05-26 15:53:13 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_ensure_initialized(generator TSRMLS_CC);
Implement return for generators For generators ZEND_RETURN directly calls ZEND_VM_RETURN(), thus passing execution back to the caller (zend_generator_resume). This commit also adds a check that only return; is used in generators and not return $value;.
2012-05-26 21:07:05 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_resume(generator TSRMLS_CC);
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
}
/* }}} */
Make $generator->send() return the current value This makes the API easier to use (and is consistent with Python and JS).
2012-05-31 18:03:18 +00:00
/* {{{ proto mixed Generator::send()
Add support for $generator->send() Yield now is an expression and the return value is the value passed to $generator->send(). By default (i.e. if ->next() is called) the value is NULL. Unlike in Python ->send() can be run without priming the generator with a ->next() call first.
2012-05-29 15:34:33 +00:00
* Sends a value to the generator */
ZEND_METHOD(Generator, send)
{
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zval *value;
Add support for $generator->send() Yield now is an expression and the return value is the value passed to $generator->send(). By default (i.e. if ->next() is called) the value is NULL. Unlike in Python ->send() can be run without priming the generator with a ->next() call first.
2012-05-29 15:34:33 +00:00
zend_generator *generator;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &value) == FAILURE) {
return;
}
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
Add support for $generator->send() Yield now is an expression and the return value is the value passed to $generator->send(). By default (i.e. if ->next() is called) the value is NULL. Unlike in Python ->send() can be run without priming the generator with a ->next() call first.
2012-05-29 15:34:33 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_ensure_initialized(generator TSRMLS_CC);
Add support for $generator->send() Yield now is an expression and the return value is the value passed to $generator->send(). By default (i.e. if ->next() is called) the value is NULL. Unlike in Python ->send() can be run without priming the generator with a ->next() call first.
2012-05-29 15:34:33 +00:00
Fix segfault when send()ing to a closed generator
2012-05-29 16:01:08 +00:00
/* The generator is already closed, thus can't send anything */
if (!generator->execute_data) {
return;
}
Fix leak when generator ignores sent value When the return value of yield wasn't used it was leaked. This is fixed by using a TMP_VAR return value instead of VAR. TMP_VARs are automatically freed when they aren't used.
2012-12-18 20:36:48 +00:00
/* Put sent value into the TMP_VAR slot */
MAKE_COPY_ZVAL(&value, &generator->send_target->tmp_var);
Add support for $generator->send() Yield now is an expression and the return value is the value passed to $generator->send(). By default (i.e. if ->next() is called) the value is NULL. Unlike in Python ->send() can be run without priming the generator with a ->next() call first.
2012-05-29 15:34:33 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_resume(generator TSRMLS_CC);
Make $generator->send() return the current value This makes the API easier to use (and is consistent with Python and JS).
2012-05-31 18:03:18 +00:00
if (generator->value) {
RETURN_ZVAL(generator->value, 1, 0);
}
Add support for $generator->send() Yield now is an expression and the return value is the value passed to $generator->send(). By default (i.e. if ->next() is called) the value is NULL. Unlike in Python ->send() can be run without priming the generator with a ->next() call first.
2012-05-29 15:34:33 +00:00
}
Fix typos
2012-08-29 18:49:14 +00:00
/* }}} */
Add support for $generator->send() Yield now is an expression and the return value is the value passed to $generator->send(). By default (i.e. if ->next() is called) the value is NULL. Unlike in Python ->send() can be run without priming the generator with a ->next() call first.
2012-05-29 15:34:33 +00:00
Fix typos
2012-08-29 18:49:14 +00:00
/* {{{ proto void Generator::__wakeup()
Disallow serialization and unserialization
2012-08-20 14:01:16 +00:00
* Throws an Exception as generators can't be serialized */
ZEND_METHOD(Generator, __wakeup)
{
/* Just specifying the zend_class_unserialize_deny handler is not enough,
* because it is only invoked for C unserialization. For O the error has
* to be thrown in __wakeup. */
if (zend_parse_parameters_none() == FAILURE) {
return;
}
zend_throw_exception(NULL, "Unserialization of 'Generator' is not allowed", 0 TSRMLS_CC);
}
/* }}} */
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
/* get_iterator implementation */
static void zend_generator_iterator_dtor(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
{
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zval *object = ((zend_generator_iterator *) iterator)->object;
zval_ptr_dtor(&object);
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
}
/* }}} */
static int zend_generator_iterator_valid(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
{
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator *generator = (zend_generator *) iterator->data;
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_ensure_initialized(generator TSRMLS_CC);
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
return generator->value != NULL ? SUCCESS : FAILURE;
}
/* }}} */
static void zend_generator_iterator_get_data(zend_object_iterator *iterator, zval ***data TSRMLS_DC) /* {{{ */
{
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator *generator = (zend_generator *) iterator->data;
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_ensure_initialized(generator TSRMLS_CC);
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
if (generator->value) {
*data = &generator->value;
} else {
*data = NULL;
}
}
/* }}} */
static int zend_generator_iterator_get_key(zend_object_iterator *iterator, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC) /* {{{ */
{
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator *generator = (zend_generator *) iterator->data;
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_ensure_initialized(generator TSRMLS_CC);
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
if (!generator->key) {
return HASH_KEY_NON_EXISTANT;
}
if (Z_TYPE_P(generator->key) == IS_LONG) {
*int_key = Z_LVAL_P(generator->key);
return HASH_KEY_IS_LONG;
}
if (Z_TYPE_P(generator->key) == IS_STRING) {
*str_key = estrndup(Z_STRVAL_P(generator->key), Z_STRLEN_P(generator->key));
*str_key_len = Z_STRLEN_P(generator->key) + 1;
return HASH_KEY_IS_STRING;
}
/* Waiting for Etienne's patch to allow arbitrary zval keys. Until then
* error out on non-int and non-string keys. */
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_error_noreturn(E_ERROR, "Currently only int and string keys can be yielded");
Fix warning of no return in non-void function
2012-12-14 09:26:42 +00:00
return HASH_KEY_NON_EXISTANT; /* Nerver reached */
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
}
/* }}} */
static void zend_generator_iterator_move_forward(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
{
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator *generator = (zend_generator *) iterator->data;
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_ensure_initialized(generator TSRMLS_CC);
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator_resume(generator TSRMLS_CC);
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
}
/* }}} */
Fix several issues and allow rewind only at/before first yield * Trying to resume a generator while it is already running now throws a fatal error. * Trying to use yield in finally while the generator is being force-closed (by GC) throws a fatal error. * Rewinding after the first yield now throws an Exception
2012-08-25 15:40:08 +00:00
static void zend_generator_iterator_rewind(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
{
zend_generator *generator = (zend_generator *) iterator->data;
zend_generator_rewind(generator TSRMLS_CC);
}
/* }}} */
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
static zend_object_iterator_funcs zend_generator_iterator_functions = {
zend_generator_iterator_dtor,
zend_generator_iterator_valid,
zend_generator_iterator_get_data,
zend_generator_iterator_get_key,
zend_generator_iterator_move_forward,
Fix several issues and allow rewind only at/before first yield * Trying to resume a generator while it is already running now throws a fatal error. * Trying to use yield in finally while the generator is being force-closed (by GC) throws a fatal error. * Rewinding after the first yield now throws an Exception
2012-08-25 15:40:08 +00:00
zend_generator_iterator_rewind
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
};
zend_object_iterator *zend_generator_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) /* {{{ */
{
zend_generator_iterator *iterator;
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
zend_generator *generator;
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
generator = (zend_generator *) zend_object_store_get_object(object TSRMLS_CC);
Fix segfault when traversing a by-ref generator twice If you try to traverse an already closed generator an exception will now be thrown. Furthermore this changes the error for traversing a by-val generator by-ref from an E_ERROR to an Exception.
2012-08-29 18:46:56 +00:00
if (!generator->execute_data) {
zend_throw_exception(NULL, "Cannot traverse an already closed generator", 0 TSRMLS_CC);
return NULL;
}
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
if (by_ref && !(generator->execute_data->op_array->fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
Fix segfault when traversing a by-ref generator twice If you try to traverse an already closed generator an exception will now be thrown. Furthermore this changes the error for traversing a by-val generator by-ref from an E_ERROR to an Exception.
2012-08-29 18:46:56 +00:00
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;
Add support by yielding by-reference
2012-07-17 11:24:27 +00:00
}
. The VM stacks for passing function arguments and syntaticaly nested calls were merged into a single stack. The stack size needed for op_array execution is calculated at compile time and preallocated at once. As result all the stack push operatins don't require checks for stack overflow any more. . Generators implementation was improved using the new VM stack. Now it's a bit more clear and faster.
2012-11-30 09:39:23 +00:00
iterator = &generator->iterator;
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
iterator->intern.funcs = &zend_generator_iterator_functions;
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
iterator->intern.data = (void *) generator;
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
/* We have to keep a reference to the generator object zval around,
* otherwise the generator may be destroyed during iteration. */
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
Z_ADDREF_P(object);
Pass zend_generator directly to Zend VM Previously the zval* of the generator was passed into the VM by misusing EG(return_value_ptr_ptr). Now the zend_generator* itself is directly passed in. This saves us from always having to pass the zval* around everywhere.
2012-06-23 12:43:52 +00:00
iterator->object = object;
Implement get_iterator This implements the get_iterator handler for Generator objects, thus making direct foreach() iteration significantly faster.
2012-06-22 23:28:16 +00:00
return (zend_object_iterator *) iterator;
}
/* }}} */
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
ZEND_BEGIN_ARG_INFO(arginfo_generator_void, 0)
ZEND_END_ARG_INFO()
Add support for $generator->send() Yield now is an expression and the return value is the value passed to $generator->send(). By default (i.e. if ->next() is called) the value is NULL. Unlike in Python ->send() can be run without priming the generator with a ->next() call first.
2012-05-29 15:34:33 +00:00
ZEND_BEGIN_ARG_INFO_EX(arginfo_generator_send, 0, 0, 1)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
Add empty Generator class
2012-05-19 22:03:27 +00:00
static const zend_function_entry generator_functions[] = {
Disallow serialization and unserialization
2012-08-20 14:01:16 +00:00
ZEND_ME(Generator, rewind, arginfo_generator_void, ZEND_ACC_PUBLIC)
ZEND_ME(Generator, valid, arginfo_generator_void, ZEND_ACC_PUBLIC)
ZEND_ME(Generator, current, arginfo_generator_void, ZEND_ACC_PUBLIC)
ZEND_ME(Generator, key, arginfo_generator_void, ZEND_ACC_PUBLIC)
ZEND_ME(Generator, next, arginfo_generator_void, ZEND_ACC_PUBLIC)
ZEND_ME(Generator, send, arginfo_generator_send, ZEND_ACC_PUBLIC)
ZEND_ME(Generator, __wakeup, arginfo_generator_void, ZEND_ACC_PUBLIC)
Add empty Generator class
2012-05-19 22:03:27 +00:00
ZEND_FE_END
};
void zend_register_generator_ce(TSRMLS_D) /* {{{ */
{
zend_class_entry ce;
INIT_CLASS_ENTRY(ce, "Generator", generator_functions);
zend_ce_generator = zend_register_internal_class(&ce TSRMLS_CC);
zend_ce_generator->ce_flags |= ZEND_ACC_FINAL_CLASS;
Add some boilerplate code for Generator class The Generator class now uses a zend_generator struct, so it'll be able to store additional info. This commit also ensures that Generator cannot be directly instantiated and extended. The error tests are now in a separate folder from the (yet-to-come) functional tests.
2012-05-20 12:19:16 +00:00
zend_ce_generator->create_object = zend_generator_create;
Disallow serialization and unserialization
2012-08-20 14:01:16 +00:00
zend_ce_generator->serialize = zend_class_serialize_deny;
zend_ce_generator->unserialize = zend_class_unserialize_deny;
Add some boilerplate code for Generator class The Generator class now uses a zend_generator struct, so it'll be able to store additional info. This commit also ensures that Generator cannot be directly instantiated and extended. The error tests are now in a separate folder from the (yet-to-come) functional tests.
2012-05-20 12:19:16 +00:00
Fix implementation of Iterator interface It looks like you have to implement the Iterator interface *before* assigning get_iterator. Otherwise the structure for user iterators isn't correctly zeroed out. Additionaly I'm setting class_entry->iterator_funcs.funcs now. Not sure if this is strictly necessary, but better safe than sorry ;)
2012-07-26 15:07:24 +00:00
/* get_iterator has to be assigned *after* implementing the inferface */
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
zend_class_implements(zend_ce_generator TSRMLS_CC, 1, zend_ce_iterator);
Fix implementation of Iterator interface It looks like you have to implement the Iterator interface *before* assigning get_iterator. Otherwise the structure for user iterators isn't correctly zeroed out. Additionaly I'm setting class_entry->iterator_funcs.funcs now. Not sure if this is strictly necessary, but better safe than sorry ;)
2012-07-26 15:07:24 +00:00
zend_ce_generator->get_iterator = zend_generator_get_iterator;
zend_ce_generator->iterator_funcs.funcs = &zend_generator_iterator_functions;
Add dummy Iterator implementation This simply adds dummy rewind/valid/current/key/next methods to Generator.
2012-05-23 14:07:15 +00:00
Add some boilerplate code for Generator class The Generator class now uses a zend_generator struct, so it'll be able to store additional info. This commit also ensures that Generator cannot be directly instantiated and extended. The error tests are now in a separate folder from the (yet-to-come) functional tests.
2012-05-20 12:19:16 +00:00
memcpy(&zend_generator_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
zend_generator_handlers.get_constructor = zend_generator_get_constructor;
Add cloning support for generators Generators can now be cloned. I'm pretty sure that my current code does not yet cover all the edge cases of cloning the execution context, so there are probably a few bugs in there :)
2012-06-02 18:40:58 +00:00
zend_generator_handlers.clone_obj = zend_objects_store_clone_obj;
Add empty Generator class
2012-05-19 22:03:27 +00:00
}
/* }}} */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* indent-tabs-mode: t
* End:
*/
Reference in New Issue Copy Permalink