php 对象调用方法

static union _zend_function *zend_std_get_method(zval **object_ptr, char *method_name, int method_len, const zend_literal *key TSRMLS_DC) /* {{{ */
{
    zend_function *fbc;
    zval *object = *object_ptr;
    zend_object *zobj = Z_OBJ_P(object);
    ulong hash_value;
    char *lc_method_name;
    ALLOCA_FLAG(use_heap)

    if (EXPECTED(key != NULL)) {
        lc_method_name = Z_STRVAL(key->constant);
        hash_value = key->hash_value;
    } else {
        lc_method_name = do_alloca(method_len+1, use_heap);
        /* Create a zend_copy_str_tolower(dest, src, src_length); */
        zend_str_tolower_copy(lc_method_name, method_name, method_len);
        hash_value = zend_hash_func(lc_method_name, method_len+1);
    }

    if (UNEXPECTED(zend_hash_quick_find(&zobj->ce->function_table, lc_method_name, method_len+1, hash_value, (void **)&fbc) == FAILURE)) {
        if (UNEXPECTED(!key)) {
            free_alloca(lc_method_name, use_heap);
        }
        if (zobj->ce->__call) {//如果找不到，调用_call()方法
            return zend_get_user_call_function(zobj->ce, method_name, method_len);
        } else {
            return NULL;
        }
    }

    /* Check access level */
    if (fbc->op_array.fn_flags & ZEND_ACC_PRIVATE) {
        zend_function *updated_fbc;

        /* Ensure that if we‘re calling a private function, we‘re allowed to do so.
         * If we‘re not and __call() handler exists, invoke it, otherwise error out.
         */
        updated_fbc = zend_check_private_int(fbc, Z_OBJ_HANDLER_P(object, get_class_entry)(object TSRMLS_CC), lc_method_name, method_len, hash_value TSRMLS_CC);
        if (EXPECTED(updated_fbc != NULL)) {
            fbc = updated_fbc;
        } else {
            if (zobj->ce->__call) {
                fbc = zend_get_user_call_function(zobj->ce, method_name, method_len);
            } else {
                zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context ‘%s‘", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), method_name, EG(scope) ? EG(scope)->name : "");
            }
        }
    } else {
        /* Ensure that we haven‘t overridden a private function and end up calling
         * the overriding public function...
         */
        if (EG(scope) &&
            is_derived_class(fbc->common.scope, EG(scope)) &&
            fbc->op_array.fn_flags & ZEND_ACC_CHANGED) {
            zend_function *priv_fbc;

            if (zend_hash_quick_find(&EG(scope)->function_table, lc_method_name, method_len+1, hash_value, (void **) &priv_fbc)==SUCCESS
                && priv_fbc->common.fn_flags & ZEND_ACC_PRIVATE
                && priv_fbc->common.scope == EG(scope)) {
                fbc = priv_fbc;
            }
        }
        if ((fbc->common.fn_flags & ZEND_ACC_PROTECTED)) {
            /* Ensure that if we‘re calling a protected function, we‘re allowed to do so.
             * If we‘re not and __call() handler exists, invoke it, otherwise error out.
             */
            if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), EG(scope)))) {
                if (zobj->ce->__call) {
                    fbc = zend_get_user_call_function(zobj->ce, method_name, method_len);
                } else {
                    zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context ‘%s‘", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), method_name, EG(scope) ? EG(scope)->name : "");
                }
            }
        }
    }

    if (UNEXPECTED(!key)) {
        free_alloca(lc_method_name, use_heap);
    }
    return fbc;
}

static inline union _zend_function *zend_get_user_call_function(zend_class_entry *ce, const char *method_name, int method_len) /* {{{ */
{
    zend_internal_function *call_user_call = emalloc(sizeof(zend_internal_function));
    call_user_call->type = ZEND_INTERNAL_FUNCTION;
    call_user_call->module = (ce->type == ZEND_INTERNAL_CLASS) ? ce->info.internal.module : NULL;
    call_user_call->handler = zend_std_call_user_call;
    call_user_call->arg_info = NULL;
    call_user_call->num_args = 0;
    call_user_call->scope = ce;
    call_user_call->fn_flags = ZEND_ACC_CALL_VIA_HANDLER;
    call_user_call->function_name = estrndup(method_name, method_len);

    return (union _zend_function *)call_user_call;
}

ZEND_API void zend_std_call_user_call(INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
{
    zend_internal_function *func = (zend_internal_function *)EG(current_execute_data)->function_state.function;
    zval *method_name_ptr, *method_args_ptr;
    zval *method_result_ptr = NULL;
    zend_class_entry *ce = Z_OBJCE_P(this_ptr);

    ALLOC_ZVAL(method_args_ptr);
    INIT_PZVAL(method_args_ptr);
    array_init_size(method_args_ptr, ZEND_NUM_ARGS());

    if (UNEXPECTED(zend_copy_parameters_array(ZEND_NUM_ARGS(), method_args_ptr TSRMLS_CC) == FAILURE)) {
        zval_dtor(method_args_ptr);
        zend_error_noreturn(E_ERROR, "Cannot get arguments for __call");
        RETURN_FALSE;
    }

    ALLOC_ZVAL(method_name_ptr);
    INIT_PZVAL(method_name_ptr);
    ZVAL_STRING(method_name_ptr, func->function_name, 0); /* no dup - it‘s a copy */

    /* __call handler is called with two arguments:
       method name
       array of method parameters

    */
    zend_call_method_with_2_params(&this_ptr, ce, &ce->__call, ZEND_CALL_FUNC_NAME, &method_result_ptr, method_name_ptr, method_args_ptr);

    if (method_result_ptr) {
        if (Z_ISREF_P(method_result_ptr) || Z_REFCOUNT_P(method_result_ptr) > 1) {
            RETVAL_ZVAL(method_result_ptr, 1, 1);
        } else {
            RETVAL_ZVAL(method_result_ptr, 0, 1);
        }
    }

    /* now destruct all auxiliaries */
    zval_ptr_dtor(&method_args_ptr);
    zval_ptr_dtor(&method_name_ptr);

    /* destruct the function also, then - we have allocated it in get_method */
    efree(func);
}

/* Ensures that we‘re allowed to call a private method.
 * Returns the function address that should be called, or NULL
 * if no such function exists.
 */
static inline zend_function *zend_check_private_int(zend_function *fbc, zend_class_entry *ce, char *function_name_strval, int function_name_strlen, ulong hash_value TSRMLS_DC) /* {{{ */
{
    if (!ce) {
        return 0;
    }

    /* We may call a private function if:
     * 1.  The class of our object is the same as the scope, and the private
     *     function (EX(fbc)) has the same scope.
     * 2.  One of our parent classes are the same as the scope, and it contains
     *     a private function with the same name that has the same scope.
     */
    if (fbc->common.scope == ce && EG(scope) == ce) {
        /* rule #1 checks out ok, allow the function call */
        return fbc;
    }


    /* Check rule #2 */
    ce = ce->parent;
    while (ce) {
        if (ce == EG(scope)) {
            if (zend_hash_quick_find(&ce->function_table, function_name_strval, function_name_strlen+1, hash_value, (void **) &fbc)==SUCCESS
                && fbc->op_array.fn_flags & ZEND_ACC_PRIVATE
                && fbc->common.scope == EG(scope)) {
                return fbc;
            }
            break;
        }
        ce = ce->parent;
    }
    return NULL;
}

ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam)
{
    Bucket *p;
    void *t;

    IS_CONSISTENT(source);
    IS_CONSISTENT(target);

    p = source->pListHead;
    while (p) {
        if (zend_hash_replace_checker_wrapper(target, p->pData, p, pParam, pMergeSource)) {
            if (zend_hash_quick_update(target, p->arKey, p->nKeyLength, p->h, p->pData, size, &t)==SUCCESS && pCopyConstructor) {
                pCopyConstructor(t);
            }
        }
        p = p->pListNext;
    }
    target->pInternalPointer = target->pListHead;
}

static zend_bool zend_hash_replace_checker_wrapper(HashTable *target, void *source_data, Bucket *p, void *pParam, merge_checker_func_t merge_checker_func)
{
    zend_hash_key hash_key;

    hash_key.arKey = p->arKey;
    hash_key.nKeyLength = p->nKeyLength;
    hash_key.h = p->h;
    return merge_checker_func(target, source_data, &hash_key, pParam);
}

static zend_bool do_inherit_property_access_check(HashTable *target_ht, zend_property_info *parent_info, const zend_hash_key *hash_key, zend_class_entry *ce) /* {{{ */
{
    zend_property_info *child_info;
    zend_class_entry *parent_ce = ce->parent;

    if (parent_info->flags & (ZEND_ACC_PRIVATE|ZEND_ACC_SHADOW)) { //如果父类中的属性是private的，则返回0，不拷贝
        if (zend_hash_quick_find(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child_info)==SUCCESS) {
            child_info->flags |= ZEND_ACC_CHANGED;
        } else {
            zend_hash_quick_update(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, parent_info, sizeof(zend_property_info), (void **) &child_info);
            if(ce->type & ZEND_INTERNAL_CLASS) {
                zend_duplicate_property_info_internal(child_info);
            } else {
                zend_duplicate_property_info(child_info);
            }
            child_info->flags &= ~ZEND_ACC_PRIVATE; /* it‘s not private anymore */
            child_info->flags |= ZEND_ACC_SHADOW; /* but it‘s a shadow of private */
        }
        return 0; /* don‘t copy access information to child */
    }

    if (zend_hash_quick_find(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child_info)==SUCCESS) {
        if ((parent_info->flags & ZEND_ACC_STATIC) != (child_info->flags & ZEND_ACC_STATIC)) {
            zend_error(E_COMPILE_ERROR, "Cannot redeclare %s%s::$%s as %s%s::$%s",
                (parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", parent_ce->name, hash_key->arKey,
                (child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ce->name, hash_key->arKey);
                
        }

        if(parent_info->flags & ZEND_ACC_CHANGED) {
            child_info->flags |= ZEND_ACC_CHANGED;
        }

        if ((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK)) {
            zend_error(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ce->name, hash_key->arKey, zend_visibility_string(parent_info->flags), parent_ce->name, (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
        } else if ((child_info->flags & ZEND_ACC_STATIC) == 0) {
            zval_ptr_dtor(&(ce->default_properties_table[parent_info->offset]));
            ce->default_properties_table[parent_info->offset] = ce->default_properties_table[child_info->offset];
            ce->default_properties_table[child_info->offset] = NULL;
            child_info->offset = parent_info->offset;
        }
        return 0;    /* Don‘t copy from parent */
    } else { 
       //子类中没有找到父类中的属性
        return 1;    /* Copy from parent */
    }
}

static void do_inheritance_check_on_method(zend_function *child, zend_function *parent TSRMLS_DC) /* {{{ */
{
    zend_uint child_flags;
    zend_uint parent_flags = parent->common.fn_flags;

    if ((parent->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0
        && parent->common.fn_flags & ZEND_ACC_ABSTRACT
        && parent->common.scope != (child->common.prototype ? child->common.prototype->common.scope : child->common.scope)
        && child->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_IMPLEMENTED_ABSTRACT)) {
        zend_error(E_COMPILE_ERROR, "Can‘t inherit abstract function %s::%s() (previously declared abstract in %s)", 
            parent->common.scope->name,
            child->common.function_name,
            child->common.prototype ? child->common.prototype->common.scope->name : child->common.scope->name);
    }

    if (parent_flags & ZEND_ACC_FINAL) {
        zend_error(E_COMPILE_ERROR, "Cannot override final method %s::%s()", ZEND_FN_SCOPE_NAME(parent), child->common.function_name);
    }

    child_flags    = child->common.fn_flags;
    /* You cannot change from static to non static and vice versa.
     */
    if ((child_flags & ZEND_ACC_STATIC) != (parent_flags & ZEND_ACC_STATIC)) {
        if (child->common.fn_flags & ZEND_ACC_STATIC) {
            zend_error(E_COMPILE_ERROR, "Cannot make non static method %s::%s() static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
        } else {
            zend_error(E_COMPILE_ERROR, "Cannot make static method %s::%s() non static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
        }
    }

    /* Disallow making an inherited method abstract. */
    if ((child_flags & ZEND_ACC_ABSTRACT) && !(parent_flags & ZEND_ACC_ABSTRACT)) {
        zend_error(E_COMPILE_ERROR, "Cannot make non abstract method %s::%s() abstract in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
    }

    if (parent_flags & ZEND_ACC_CHANGED) {
        child->common.fn_flags |= ZEND_ACC_CHANGED;
    } else {
        /* Prevent derived classes from restricting access that was available in parent classes
         */
        if ((child_flags & ZEND_ACC_PPP_MASK) > (parent_flags & ZEND_ACC_PPP_MASK)) {
            zend_error(E_COMPILE_ERROR, "Access level to %s::%s() must be %s (as in class %s)%s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
        } else if (((child_flags & ZEND_ACC_PPP_MASK) < (parent_flags & ZEND_ACC_PPP_MASK))
            && ((parent_flags & ZEND_ACC_PPP_MASK) & ZEND_ACC_PRIVATE)) {
            child->common.fn_flags |= ZEND_ACC_CHANGED;
        }
    }

    if (parent_flags & ZEND_ACC_PRIVATE) {
        child->common.prototype = NULL;        
    } else if (parent_flags & ZEND_ACC_ABSTRACT) {
        child->common.fn_flags |= ZEND_ACC_IMPLEMENTED_ABSTRACT;
        child->common.prototype = parent;
    } else if (!(parent->common.fn_flags & ZEND_ACC_CTOR) || (parent->common.prototype && (parent->common.prototype->common.scope->ce_flags & ZEND_ACC_INTERFACE))) {
        /* ctors only have a prototype if it comes from an interface */
        child->common.prototype = parent->common.prototype ? parent->common.prototype : parent;
    }

    if (child->common.prototype && (child->common.prototype->common.fn_flags & ZEND_ACC_ABSTRACT)) {
        if (!zend_do_perform_implementation_check(child, child->common.prototype TSRMLS_CC)) {
            zend_error(E_COMPILE_ERROR, "Declaration of %s::%s() must be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, zend_get_function_declaration(child->common.prototype? child->common.prototype : parent TSRMLS_CC)); 
        }
    } else if (EG(error_reporting) & E_STRICT || EG(user_error_handler)) { /* Check E_STRICT (or custom error handler) before the check so that we save some time */
        if (!zend_do_perform_implementation_check(child, parent TSRMLS_CC)) {
            char *method_prototype = zend_get_function_declaration(child->common.prototype? child->common.prototype : parent TSRMLS_CC);
            zend_error(E_STRICT, "Declaration of %s::%s() should be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, method_prototype); 
            efree(method_prototype);
        }
    }
}