变量赋值(非引用) php内核的实现(三）

<?php
　　$a=1;
　　$b=&a;
　　$c=2;
　　$d=$c;
　　$c=$b;

<?php
 $a=1;
 $b=&$a;
 $c=2;
 $b=$c;

static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
    USE_OPLINE

    zval *value;
    zval **variable_ptr_ptr;

    SAVE_OPLINE();
    value = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC);
    variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC);

    if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
        if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) {
            if (RETURN_VALUE_USED(opline)) {
                zval *retval;

                ALLOC_ZVAL(retval);
                ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
                INIT_PZVAL(retval);
                AI_SET_PTR(&EX_T(opline->result.var), retval);
            }
        } else if (RETURN_VALUE_USED(opline)) {
            PZVAL_LOCK(&EG(uninitialized_zval));
            AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
        }
    } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
        if (0) {
            zval_dtor(value);
        }
        if (RETURN_VALUE_USED(opline)) {
            PZVAL_LOCK(&EG(uninitialized_zval));
            AI_SET_PTR(&EX_T(opline->result.var), &EG(uninitialized_zval));
        }
    } else {
        if (IS_CV == IS_TMP_VAR) {
             value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
        } else if (IS_CV == IS_CONST) {
             value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
        } else {
             value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
        }
        if (RETURN_VALUE_USED(opline)) {
            PZVAL_LOCK(value);
            AI_SET_PTR(&EX_T(opline->result.var), value);
        }
    }

    /* zend_assign_to_variable() always takes care of op2, never free it! */

    CHECK_EXCEPTION();
    ZEND_VM_NEXT_OPCODE();
}

static inline zval* zend_assign_to_variable(zval **variable_ptr_ptr, zval *value TSRMLS_DC)
{
    zval *variable_ptr = *variable_ptr_ptr;
    zval garbage;

    if (Z_TYPE_P(variable_ptr) == IS_OBJECT &&
        UNEXPECTED(Z_OBJ_HANDLER_P(variable_ptr, set) != NULL)) {
        Z_OBJ_HANDLER_P(variable_ptr, set)(variable_ptr_ptr, value TSRMLS_CC);
        return variable_ptr;
    }

     if (EXPECTED(!PZVAL_IS_REF(variable_ptr))) {
        if (Z_REFCOUNT_P(variable_ptr)==1) {
            if (UNEXPECTED(variable_ptr == value)) {
                return variable_ptr;
            } else if (EXPECTED(!PZVAL_IS_REF(value))) {
                Z_ADDREF_P(value);
                *variable_ptr_ptr = value;
                if (EXPECTED(variable_ptr != &EG(uninitialized_zval))) {
                    GC_REMOVE_ZVAL_FROM_BUFFER(variable_ptr);
                    zval_dtor(variable_ptr);
                    efree(variable_ptr);
                } else {
                    Z_DELREF_P(variable_ptr);
                }
                return value;
            } else {
                goto copy_value;
            }
        } else { /* we need to split */
            Z_DELREF_P(variable_ptr);
            GC_ZVAL_CHECK_POSSIBLE_ROOT(variable_ptr);
            if (PZVAL_IS_REF(value) && Z_REFCOUNT_P(value) > 0) {
                ALLOC_ZVAL(variable_ptr);
                *variable_ptr_ptr = variable_ptr;
                INIT_PZVAL_COPY(variable_ptr, value);
                zval_copy_ctor(variable_ptr);
                return variable_ptr;
            } else {
                *variable_ptr_ptr = value;
                Z_ADDREF_P(value);
                Z_UNSET_ISREF_P(value);
                return value;
            }
        }
     } else {
        if (EXPECTED(variable_ptr != value)) {
copy_value:
            if (EXPECTED(Z_TYPE_P(variable_ptr) <= IS_BOOL)) {
                /* nothing to destroy */
                ZVAL_COPY_VALUE(variable_ptr, value);
                zendi_zval_copy_ctor(*variable_ptr);
            } else {
                ZVAL_COPY_VALUE(&garbage, variable_ptr);
                ZVAL_COPY_VALUE(variable_ptr, value);
                zendi_zval_copy_ctor(*variable_ptr);
                _zval_dtor_func(&garbage ZEND_FILE_LINE_CC);
            }
        }
        return variable_ptr;
    }
}

//zend.h

#define INIT_PZVAL_COPY(z, v)                        do {                                                ZVAL_COPY_VALUE(z, v);                            Z_SET_REFCOUNT_P(z, 1);                            Z_UNSET_ISREF_P(z);                            } while (0)

　static zend_always_inline zend_bool zval_unset_isref_p(zval* pz) {
　　　return pz->is_ref__gc = 0;
　}