Fixed parameter passing incompatibilities.

Now it is possible to call array_pop(explode("&","1&2&3")) again.

diff --git a/Zend/tests/bug33257.phpt b/Zend/tests/bug33257.phpt
index b3e98003a391608dc67aa56aa65e0713779d8df1..012faf350b27be6a2ae3158312505ee6217f83f2 100755 (executable)
--- a/Zend/tests/bug33257.phpt
+++ b/Zend/tests/bug33257.phpt
@@ -14,4 +14,10 @@ array_splice(X::getArr(), 1, 1);
 print_r(X::getArr());
 ?>
 --EXPECTF--
-Fatal error: Only variables can be passed by reference in %sbug33257.php on line 10
+Strict Standards: Only variables should be passed by reference in %sbug33257.php on line 10
+Array
+(
+    [0] => a
+    [1] => b
+    [2] => c
+)

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 55640c7a21a849c35e7f8ec700e06122c178083f..25358fc72f069dd2a85c0ac8ed993d05227f40ab 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -2224,6 +2224,9 @@ ZEND_VM_HELPER(zend_send_by_var_helper, VAR|CV, ANY)
 ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR|CV, ANY)
 {
        zend_op *opline = EX(opline);
+       zend_free_op free_op1;
+       zval *varptr;
+
        if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
                if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
                        ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
@@ -2231,23 +2234,27 @@ ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR|CV, ANY)
        } else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
                ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
        }
-       if ((opline->extended_value & ZEND_ARG_SEND_FUNCTION) &&
-           !EX_T(opline->op1.u.var).var.fcall_returned_reference) {
-               zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
+
+       varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+       if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
+            EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
+           varptr != &EG(uninitialized_zval) && 
+           (PZVAL_IS_REF(varptr) || varptr->refcount == 1)) {
+               varptr->is_ref = 1;
+               varptr->refcount++;
+               zend_ptr_stack_push(&EG(argument_stack), varptr);
        } else {
-               zval *varptr;
-               zend_free_op free_op1;
-               varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+               zval *valptr;
 
-               if (varptr != &EG(uninitialized_zval) && (PZVAL_IS_REF(varptr) || varptr->refcount == 1)) {
-                       varptr->is_ref = 1;
-                       varptr->refcount++;
-                       zend_ptr_stack_push(&EG(argument_stack), varptr);
-                       FREE_OP1_IF_VAR();
-                       ZEND_VM_NEXT_OPCODE();
+               zend_error(E_STRICT, "Only variables should be passed by reference");
+               ALLOC_ZVAL(valptr);
+               INIT_PZVAL_COPY(valptr, varptr);
+               if (!IS_OP1_TMP_FREE()) {
+                       zval_copy_ctor(valptr);
                }
-               zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
+               zend_ptr_stack_push(&EG(argument_stack), valptr);
        }
+       FREE_OP1_IF_VAR();
        ZEND_VM_NEXT_OPCODE();
 }
 

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 0d5d05e9d574173b567e3b7beeb29d30233eb606..81f2fe9e51596688c810e5c29f5304eea58c7d70 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -7331,6 +7331,9 @@ static int zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
+       zend_free_op free_op1;
+       zval *varptr;
+
        if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
                if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
                        return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -7338,23 +7341,27 @@ static int ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        } else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
                return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
        }
-       if ((opline->extended_value & ZEND_ARG_SEND_FUNCTION) &&
-           !EX_T(opline->op1.u.var).var.fcall_returned_reference) {
-               zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
+
+       varptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+       if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
+            EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
+           varptr != &EG(uninitialized_zval) && 
+           (PZVAL_IS_REF(varptr) || varptr->refcount == 1)) {
+               varptr->is_ref = 1;
+               varptr->refcount++;
+               zend_ptr_stack_push(&EG(argument_stack), varptr);
        } else {
-               zval *varptr;
-               zend_free_op free_op1;
-               varptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
+               zval *valptr;
 
-               if (varptr != &EG(uninitialized_zval) && (PZVAL_IS_REF(varptr) || varptr->refcount == 1)) {
-                       varptr->is_ref = 1;
-                       varptr->refcount++;
-                       zend_ptr_stack_push(&EG(argument_stack), varptr);
-                       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-                       ZEND_VM_NEXT_OPCODE();
+               zend_error(E_STRICT, "Only variables should be passed by reference");
+               ALLOC_ZVAL(valptr);
+               INIT_PZVAL_COPY(valptr, varptr);
+               if (!0) {
+                       zval_copy_ctor(valptr);
                }
-               zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
+               zend_ptr_stack_push(&EG(argument_stack), valptr);
        }
+       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        ZEND_VM_NEXT_OPCODE();
 }
 
@@ -20097,6 +20104,9 @@ static int zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
+       
+       zval *varptr;
+
        if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
                if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) {
                        return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -20104,23 +20114,27 @@ static int ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        } else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
                return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
        }
-       if ((opline->extended_value & ZEND_ARG_SEND_FUNCTION) &&
-           !EX_T(opline->op1.u.var).var.fcall_returned_reference) {
-               zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
-       } else {
-               zval *varptr;
-               
-               varptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 
-               if (varptr != &EG(uninitialized_zval) && (PZVAL_IS_REF(varptr) || varptr->refcount == 1)) {
-                       varptr->is_ref = 1;
-                       varptr->refcount++;
-                       zend_ptr_stack_push(&EG(argument_stack), varptr);
+       varptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
+       if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
+            EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
+           varptr != &EG(uninitialized_zval) && 
+           (PZVAL_IS_REF(varptr) || varptr->refcount == 1)) {
+               varptr->is_ref = 1;
+               varptr->refcount++;
+               zend_ptr_stack_push(&EG(argument_stack), varptr);
+       } else {
+               zval *valptr;
 
-                       ZEND_VM_NEXT_OPCODE();
+               zend_error(E_STRICT, "Only variables should be passed by reference");
+               ALLOC_ZVAL(valptr);
+               INIT_PZVAL_COPY(valptr, varptr);
+               if (!0) {
+                       zval_copy_ctor(valptr);
                }
-               zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
+               zend_ptr_stack_push(&EG(argument_stack), valptr);
        }
+
        ZEND_VM_NEXT_OPCODE();
 }