@@ -4213,20 +4213,18 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
4213
4213
{
4214
4214
USE_OPLINE
4215
4215
zend_free_op free_op1 ;
4216
- zval * array_ptr ;
4216
+ zval * array_ptr , * array_ref ;
4217
4217
HashTable * fe_ht ;
4218
4218
zend_object_iterator * iter = NULL ;
4219
4219
zend_class_entry * ce = NULL ;
4220
4220
zend_bool is_empty = 0 ;
4221
- zval * array_ref = NULL ;
4222
4221
4223
4222
SAVE_OPLINE ();
4224
4223
4225
4224
if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR ) &&
4226
4225
(opline -> extended_value & ZEND_FE_RESET_VARIABLE )) {
4227
- array_ptr = GET_OP1_ZVAL_PTR_PTR (BP_VAR_R );
4228
- if (Z_ISREF_P (array_ptr )) {
4229
- array_ref = array_ptr ;
4226
+ array_ptr = array_ref = GET_OP1_ZVAL_PTR_PTR (BP_VAR_R );
4227
+ if (Z_ISREF_P (array_ref )) {
4230
4228
array_ptr = Z_REFVAL_P (array_ptr );
4231
4229
}
4232
4230
if (Z_TYPE_P (array_ptr ) == IS_NULL ) {
@@ -4238,27 +4236,29 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
4238
4236
4239
4237
ce = Z_OBJCE_P (array_ptr );
4240
4238
if (!ce || ce -> get_iterator == NULL ) {
4241
- if (!array_ref ) {
4239
+ if (!Z_ISREF_P ( array_ref ) ) {
4242
4240
SEPARATE_ZVAL (array_ptr );
4243
4241
}
4244
4242
Z_ADDREF_P (array_ptr );
4245
4243
}
4244
+ array_ref = array_ptr ;
4246
4245
} else {
4247
4246
if (Z_TYPE_P (array_ptr ) == IS_ARRAY ) {
4248
- if (!array_ref ) {
4247
+ if (!Z_ISREF_P ( array_ref ) ) {
4249
4248
SEPARATE_ZVAL (array_ptr );
4249
+ array_ref = array_ptr ;
4250
4250
if (opline -> extended_value & ZEND_FE_FETCH_BYREF ) {
4251
4251
ZVAL_NEW_REF (array_ptr , array_ptr );
4252
+ array_ref = array_ptr ;
4252
4253
array_ptr = Z_REFVAL_P (array_ptr );
4253
4254
}
4254
4255
}
4255
4256
}
4256
- if (Z_REFCOUNTED_P (array_ptr )) Z_ADDREF_P (array_ptr );
4257
+ if (Z_REFCOUNTED_P (array_ref )) Z_ADDREF_P (array_ref );
4257
4258
}
4258
4259
} else {
4259
- array_ptr = GET_OP1_ZVAL_PTR (BP_VAR_R );
4260
- if (Z_ISREF_P (array_ptr )) {
4261
- array_ref = array_ptr ;
4260
+ array_ptr = array_ref = GET_OP1_ZVAL_PTR (BP_VAR_R );
4261
+ if (Z_ISREF_P (array_ref )) {
4262
4262
array_ptr = Z_REFVAL_P (array_ptr );
4263
4263
}
4264
4264
if (IS_OP1_TMP_FREE ()) { /* IS_TMP_VAR */
@@ -4269,33 +4269,33 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
4269
4269
if (Z_TYPE_P (array_ptr ) == IS_OBJECT ) {
4270
4270
ce = Z_OBJCE_P (array_ptr );
4271
4271
if (ce && ce -> get_iterator ) {
4272
- Z_DELREF_P (array_ptr );
4272
+ Z_DELREF_P (array_ref );
4273
4273
}
4274
4274
}
4275
4275
} else if (Z_TYPE_P (array_ptr ) == IS_OBJECT ) {
4276
4276
ce = Z_OBJCE_P (array_ptr );
4277
4277
if (!ce || !ce -> get_iterator ) {
4278
4278
if (OP1_TYPE == IS_CV ) {
4279
- Z_ADDREF_P (array_ptr );
4279
+ Z_ADDREF_P (array_ref );
4280
4280
}
4281
4281
}
4282
- } else if (Z_REFCOUNTED_P (array_ptr )) {
4282
+ } else if (Z_REFCOUNTED_P (array_ref )) {
4283
4283
if (OP1_TYPE == IS_CONST ||
4284
4284
(OP1_TYPE == IS_CV &&
4285
- (array_ref == NULL ) &&
4286
- Z_REFCOUNT_P (array_ptr ) > 1 ) ||
4285
+ ! Z_ISREF_P (array_ref ) &&
4286
+ Z_REFCOUNT_P (array_ref ) > 1 ) ||
4287
4287
(OP1_TYPE == IS_VAR &&
4288
- (array_ref == NULL ) &&
4289
- Z_REFCOUNT_P (array_ptr ) > 2 )) {
4288
+ ! Z_ISREF_P (array_ref ) &&
4289
+ Z_REFCOUNT_P (array_ref ) > 2 )) {
4290
4290
zval tmp ;
4291
4291
4292
4292
if (OP1_TYPE == IS_VAR ) {
4293
- Z_DELREF_P (array_ptr );
4293
+ Z_DELREF_P (array_ref );
4294
4294
}
4295
- ZVAL_DUP (& tmp , array_ptr );
4296
- array_ptr = & tmp ;
4295
+ ZVAL_DUP (& tmp , array_ref );
4296
+ array_ptr = array_ref = & tmp ;
4297
4297
} else if (OP1_TYPE == IS_CV ) {
4298
- Z_ADDREF_P (array_ptr );
4298
+ Z_ADDREF_P (array_ref );
4299
4299
}
4300
4300
}
4301
4301
}
@@ -4309,8 +4309,9 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
4309
4309
if (iter && EXPECTED (EG (exception ) == NULL )) {
4310
4310
zval iterator ;
4311
4311
4312
- array_ptr = & iterator ;
4312
+ array_ptr = array_ref = & iterator ;
4313
4313
ZVAL_OBJ (array_ptr , & iter -> std );
4314
+
4314
4315
} else {
4315
4316
if (OP1_TYPE == IS_VAR && opline -> extended_value & ZEND_FE_RESET_VARIABLE ) {
4316
4317
FREE_OP1_VAR_PTR ();
@@ -4323,14 +4324,14 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
4323
4324
}
4324
4325
}
4325
4326
4326
- ZVAL_COPY_VALUE (EX_VAR (opline -> result .var ), array_ptr );
4327
+ ZVAL_COPY_VALUE (EX_VAR (opline -> result .var ), array_ref );
4327
4328
4328
4329
if (iter ) {
4329
4330
iter -> index = 0 ;
4330
4331
if (iter -> funcs -> rewind ) {
4331
4332
iter -> funcs -> rewind (iter TSRMLS_CC );
4332
4333
if (UNEXPECTED (EG (exception ) != NULL )) {
4333
- zval_ptr_dtor (array_ptr );
4334
+ zval_ptr_dtor (array_ref );
4334
4335
if (OP1_TYPE == IS_VAR && opline -> extended_value & ZEND_FE_RESET_VARIABLE ) {
4335
4336
FREE_OP1_VAR_PTR ();
4336
4337
}
@@ -4339,7 +4340,7 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
4339
4340
}
4340
4341
is_empty = iter -> funcs -> valid (iter TSRMLS_CC ) != SUCCESS ;
4341
4342
if (UNEXPECTED (EG (exception ) != NULL )) {
4342
- zval_ptr_dtor (array_ptr );
4343
+ zval_ptr_dtor (array_ref );
4343
4344
if (OP1_TYPE == IS_VAR && opline -> extended_value & ZEND_FE_RESET_VARIABLE ) {
4344
4345
FREE_OP1_VAR_PTR ();
4345
4346
}
@@ -4386,12 +4387,16 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
4386
4387
{
4387
4388
USE_OPLINE
4388
4389
zend_free_op free_op1 ;
4389
- zval * array = EX_VAR ( opline -> op1 . var ) ;
4390
+ zval * array , * array_ref ;
4390
4391
zval * value ;
4391
4392
HashTable * fe_ht ;
4392
4393
zend_object_iterator * iter = NULL ;
4393
-
4394
4394
zval * key = NULL ;
4395
+
4396
+ array = array_ref = EX_VAR (opline -> op1 .var );
4397
+ if (Z_TYPE_P (array ) == IS_REFERENCE ) {
4398
+ array = Z_REFVAL_P (array );
4399
+ }
4395
4400
if (opline -> extended_value & ZEND_FE_FETCH_WITH_KEY ) {
4396
4401
key = EX_VAR ((opline + 1 )-> result .var );
4397
4402
}
@@ -4461,22 +4466,22 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
4461
4466
* In case that ever happens we need an additional flag. */
4462
4467
iter -> funcs -> move_forward (iter TSRMLS_CC );
4463
4468
if (UNEXPECTED (EG (exception ) != NULL )) {
4464
- zval_ptr_dtor (array );
4469
+ zval_ptr_dtor (array_ref );
4465
4470
HANDLE_EXCEPTION ();
4466
4471
}
4467
4472
}
4468
4473
/* If index is zero we come from FE_RESET and checked valid() already. */
4469
4474
if (!iter || (iter -> index > 0 && iter -> funcs -> valid (iter TSRMLS_CC ) == FAILURE )) {
4470
4475
/* reached end of iteration */
4471
4476
if (UNEXPECTED (EG (exception ) != NULL )) {
4472
- zval_ptr_dtor (array );
4477
+ zval_ptr_dtor (array_ref );
4473
4478
HANDLE_EXCEPTION ();
4474
4479
}
4475
4480
ZEND_VM_JMP (EX (op_array )-> opcodes + opline -> op2 .opline_num );
4476
4481
}
4477
4482
value = iter -> funcs -> get_current_data (iter TSRMLS_CC );
4478
4483
if (UNEXPECTED (EG (exception ) != NULL )) {
4479
- zval_ptr_dtor (array );
4484
+ zval_ptr_dtor (array_ref );
4480
4485
HANDLE_EXCEPTION ();
4481
4486
}
4482
4487
if (!value ) {
@@ -4487,7 +4492,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
4487
4492
if (iter -> funcs -> get_current_key ) {
4488
4493
iter -> funcs -> get_current_key (iter , key TSRMLS_CC );
4489
4494
if (UNEXPECTED (EG (exception ) != NULL )) {
4490
- zval_ptr_dtor (array );
4495
+ zval_ptr_dtor (array_ref );
4491
4496
HANDLE_EXCEPTION ();
4492
4497
}
4493
4498
} else {
0 commit comments