Coverage Report

Created: 2025-06-13 06:43

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