com php-src: Merge branch 'PHP-5.4': Zend/zend_vm_def.h Zend/zend_vm_execute.h

From: Date: Thu, 27 Sep 2012 16:46:27 +0000
Subject: com php-src: Merge branch 'PHP-5.4': Zend/zend_vm_def.h Zend/zend_vm_execute.h
Groups: php.cvs 
Request: Send a blank email to php-cvs+get-70244@lists.php.net to get a copy of this message
Commit: aaabac2473e53327bf0587876799ca4aed6c9c19 Author: Nikita Popov <nikic@php.net> Thu, 27 Sep 2012 18:46:27 +0200 Parents: da96aa848fc4845399d4d7a7c396fa31ffb9ffba 592b232e834ed2698fa97ad4dd58e5ab21f257be Branches: master Link: http://git.php.net/?p=php-src.git;a=commitdiff;h=aaabac2473e53327bf0587876799ca4aed6c9c19 Log: Merge branch 'PHP-5.4' Conflicts: Zend/zend_vm_def.h Changed paths: MM Zend/zend_vm_def.h MM Zend/zend_vm_execute.h

diff --cc Zend/zend_vm_def.h index e0fc1bf,9d475a6..ab5102f --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@@ -2467,428 -2501,296 +2467,432 @@@ ZEND_VM_HANDLER(55, ZEND_ADD_STRING, TM ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HELPER(zend_leave_helper, ANY, ANY) +ZEND_VM_HANDLER(56, ZEND_ADD_VAR, TMP|UNUSED, TMP|VAR|CV) { - zend_bool nested; - zend_op_array *op_array = EX(op_array); + USE_OPLINE + zend_free_op free_op2; + zval *str = &EX_T(opline->result.var).tmp_var; + zval *var; + zval var_copy; + int use_copy = 0; - EG(current_execute_data) = EX(prev_execute_data); - EG(opline_ptr) = NULL; - if (!EG(active_symbol_table)) { - zval ***cv = EX_CVs(); - zval ***end = cv + op_array->last_var; - while (cv != end) { - if (*cv) { - zval_ptr_dtor(*cv); - } - cv++; - } - } + SAVE_OPLINE(); + var = GET_OP2_ZVAL_PTR(BP_VAR_R); - if ((op_array->fn_flags & ZEND_ACC_CLOSURE) && op_array->prototype) { - zval_ptr_dtor((zval**)&op_array->prototype); + if (OP1_TYPE == IS_UNUSED) { + /* Initialize for erealloc in add_string_to_string */ + Z_STRVAL_P(str) = NULL; + Z_STRLEN_P(str) = 0; + Z_TYPE_P(str) = IS_STRING; + + INIT_PZVAL(str); } - nested = EX(nested); + if (Z_TYPE_P(var) != IS_STRING) { + zend_make_printable_zval(var, &var_copy, &use_copy); - zend_vm_stack_free(execute_data TSRMLS_CC); + if (use_copy) { + var = &var_copy; + } + } + add_string_to_string(str, str, var); - if (nested) { - execute_data = EG(current_execute_data); + if (use_copy) { + zval_dtor(var); } - if (nested) { - USE_OPLINE + /* original comment, possibly problematic: + * FREE_OP is missing intentionally here - we're always working on the same temporary variable + * (Zeev): I don't think it's problematic, we only use variables + * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're + * string offsets or overloaded objects + */ + FREE_OP2(); - LOAD_REGS(); - LOAD_OPLINE(); - if (UNEXPECTED(opline->opcode == ZEND_INCLUDE_OR_EVAL)) { + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} - EX(function_state).function = (zend_function *) EX(op_array); - EX(function_state).arguments = NULL; - EX(object) = EX(current_object); +ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMP|VAR|UNUSED|CV) +{ + USE_OPLINE - EG(opline_ptr) = &EX(opline); - EG(active_op_array) = EX(op_array); - EG(return_value_ptr_ptr) = EX(original_return_value); - destroy_op_array(op_array TSRMLS_CC); - efree(op_array); - if (UNEXPECTED(EG(exception) != NULL)) { - zend_throw_exception_internal(NULL TSRMLS_CC); - HANDLE_EXCEPTION_LEAVE(); - } else if (RETURN_VALUE_USED(opline)) { - if (!EX_T(opline->result.var).var.ptr) { /* there was no return statement */ - zval *retval; + SAVE_OPLINE(); + if (EG(exception)) { + zend_exception_save(TSRMLS_C); + } + if (OP2_TYPE == IS_UNUSED) { + EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else { + zend_free_op free_op2; + zval *class_name = GET_OP2_ZVAL_PTR(BP_VAR_R); - ALLOC_ZVAL(retval); - ZVAL_BOOL(retval, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } + if (OP2_TYPE == IS_CONST) { + if (CACHED_PTR(opline->op2.literal->cache_slot)) { + EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot); + } else { + EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); + CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry); } - - ZEND_VM_INC_OPCODE(); - ZEND_VM_LEAVE(); + } else if (Z_TYPE_P(class_name) == IS_OBJECT) { + EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name); + } else if (Z_TYPE_P(class_name) == IS_STRING) { + EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC); } else { + zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string"); + } - EG(opline_ptr) = &EX(opline); - EG(active_op_array) = EX(op_array); - EG(return_value_ptr_ptr) = EX(original_return_value); - if (EG(active_symbol_table)) { - if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) { - zend_hash_destroy(EG(active_symbol_table)); - FREE_HASHTABLE(EG(active_symbol_table)); - } else { - /* clean before putting into the cache, since clean - could call dtors, which could use cached hash */ - zend_hash_clean(EG(active_symbol_table)); - *(++EG(symtable_cache_ptr)) = EG(active_symbol_table); - } - } - EG(active_symbol_table) = EX(symbol_table); + FREE_OP2(); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } +} - EX(function_state).function = (zend_function *) EX(op_array); - EX(function_state).arguments = NULL; +ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV) +{ + USE_OPLINE + zval *function_name; + char *function_name_strval; + int function_name_strlen; + zend_free_op free_op1, free_op2; - if (EG(This)) { - if (UNEXPECTED(EG(exception) != NULL) && IS_CTOR_CALL(EX(called_scope))) { - if (IS_CTOR_USED(EX(called_scope))) { - Z_DELREF_P(EG(This)); - } - if (Z_REFCOUNT_P(EG(This)) == 1) { - zend_object_store_ctor_failed(EG(This) TSRMLS_CC); - } - } - zval_ptr_dtor(&EG(This)); - } - EG(This) = EX(current_this); - EG(scope) = EX(current_scope); - EG(called_scope) = EX(current_called_scope); + SAVE_OPLINE(); + zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); - EX(object) = EX(current_object); - EX(called_scope) = DECODE_CTOR(EX(called_scope)); + function_name = GET_OP2_ZVAL_PTR(BP_VAR_R); - zend_vm_stack_clear_multiple(TSRMLS_C); + if (OP2_TYPE != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + zend_error_noreturn(E_ERROR, "Method name must be a string"); + } - if (UNEXPECTED(EG(exception) != NULL)) { - zend_throw_exception_internal(NULL TSRMLS_CC); - if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) { - zval_ptr_dtor(&EX_T(opline->result.var).var.ptr); - } - HANDLE_EXCEPTION_LEAVE(); + function_name_strval = Z_STRVAL_P(function_name); + function_name_strlen = Z_STRLEN_P(function_name); + + EX(object) = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R); + + if (EXPECTED(EX(object) != NULL) && + EXPECTED(Z_TYPE_P(EX(object)) == IS_OBJECT)) { + EX(called_scope) = Z_OBJCE_P(EX(object)); + + if (OP2_TYPE != IS_CONST || + (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope))) == NULL) { + zval *object = EX(object); + + if (UNEXPECTED(Z_OBJ_HT_P(EX(object))->get_method == NULL)) { + zend_error_noreturn(E_ERROR, "Object does not support method calls"); } - ZEND_VM_INC_OPCODE(); - ZEND_VM_LEAVE(); + /* First, locate the function. */ + EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen, ((OP2_TYPE == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + if (UNEXPECTED(EX(fbc) == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval); + } + if (OP2_TYPE == IS_CONST && + EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && + EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && + EXPECTED(EX(object) == object)) { + CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, EX(called_scope), EX(fbc)); + } } + } else { + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); } - ZEND_VM_RETURN(); + + if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { + EX(object) = NULL; + } else { + if (!PZVAL_IS_REF(EX(object))) { + Z_ADDREF_P(EX(object)); /* For $this pointer */ + } else { + zval *this_ptr; + ALLOC_ZVAL(this_ptr); + INIT_PZVAL_COPY(this_ptr, EX(object)); + zval_copy_ctor(this_ptr); + EX(object) = this_ptr; + } + } + + FREE_OP2(); + FREE_OP1_IF_VAR(); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY) +ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUSED|CV) { USE_OPLINE - zend_bool should_change_scope = 0; - zend_function *fbc = EX(function_state).function; + zval *function_name; + zend_class_entry *ce; SAVE_OPLINE(); - if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) { - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) { - zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name, fbc->common.function_name); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); /* Never reached */ - } - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { - zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated", - fbc->common.scope ? fbc->common.scope->name : "", - fbc->common.scope ? "::" : "", - fbc->common.function_name); - } - } - if (fbc->common.scope && - !(fbc->common.fn_flags & ZEND_ACC_STATIC) && - !EX(object)) { + zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); - if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - /* FIXME: output identifiers properly */ - zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", fbc->common.scope->name, fbc->common.function_name); + if (OP1_TYPE == IS_CONST) { + /* no function found. try a static method in class */ + if (CACHED_PTR(opline->op1.literal->cache_slot)) { + ce = CACHED_PTR(opline->op1.literal->cache_slot); } else { - /* FIXME: output identifiers properly */ - /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", fbc->common.scope->name, fbc->common.function_name); + ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + if (UNEXPECTED(ce == NULL)) { + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } + CACHE_PTR(opline->op1.literal->cache_slot, ce); } - } + EX(called_scope) = ce; + } else { + ce = EX_T(opline->op1.var).class_entry; - if (fbc->type == ZEND_USER_FUNCTION || fbc->common.scope) { - should_change_scope = 1; - EX(current_this) = EG(This); - EX(current_scope) = EG(scope); - EX(current_called_scope) = EG(called_scope); - EG(This) = EX(object); - EG(scope) = (fbc->type == ZEND_USER_FUNCTION || !EX(object)) ? fbc->common.scope : NULL; - EG(called_scope) = EX(called_scope); + if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { + EX(called_scope) = EG(called_scope); + } else { + EX(called_scope) = ce; + } } - zend_arg_types_stack_3_pop(&EG(arg_types_stack), &EX(called_scope), &EX(current_object), &EX(fbc)); - EX(function_state).arguments = zend_vm_stack_push_args(opline->extended_value TSRMLS_CC); - LOAD_OPLINE(); + if (OP1_TYPE == IS_CONST && + OP2_TYPE == IS_CONST && + CACHED_PTR(opline->op2.literal->cache_slot)) { + EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); + } else if (OP1_TYPE != IS_CONST && + OP2_TYPE == IS_CONST && + (EX(fbc) = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { + /* do nothing */ + } else if (OP2_TYPE != IS_UNUSED) { + char *function_name_strval = NULL; + int function_name_strlen = 0; + zend_free_op free_op2; - if (fbc->type == ZEND_INTERNAL_FUNCTION) { - temp_variable *ret = &EX_T(opline->result.var); + if (OP2_TYPE == IS_CONST) { + function_name_strval = Z_STRVAL_P(opline->op2.zv); + function_name_strlen = Z_STRLEN_P(opline->op2.zv); + } else { + function_name = GET_OP2_ZVAL_PTR(BP_VAR_R); - MAKE_STD_ZVAL(ret->var.ptr); - ZVAL_NULL(ret->var.ptr); - ret->var.ptr_ptr = &ret->var.ptr; - ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + zend_error_noreturn(E_ERROR, "Function name must be a string"); + } else { + function_name_strval = Z_STRVAL_P(function_name); + function_name_strlen = Z_STRLEN_P(function_name); + } + } - if (fbc->common.arg_info) { - zend_uint i=0; - zval **p = (zval**)EX(function_state).arguments; - ulong arg_count = opline->extended_value; + if (function_name_strval) { + if (ce->get_static_method) { + EX(fbc) = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); + } else { + EX(fbc) = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((OP2_TYPE == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + } + if (UNEXPECTED(EX(fbc) == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); + } + if (OP2_TYPE == IS_CONST && + EXPECTED(EX(fbc)->type <= ZEND_USER_FUNCTION) && + EXPECTED((EX(fbc)->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { + if (OP1_TYPE == IS_CONST) { + CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); + } else { + CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, EX(fbc)); + } + } + } + if (OP2_TYPE != IS_CONST) { + FREE_OP2(); + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot call constructor"); + } + if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); + } + EX(fbc) = ce->constructor; + } - while (arg_count>0) { - zend_verify_arg_type(fbc, ++i, *(p-arg_count), 0 TSRMLS_CC); - arg_count--; + if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) { + EX(object) = NULL; + } else { + if (EG(This) && + Z_OBJ_HT_P(EG(This))->get_class_entry && + !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { + /* We are calling method of the other (incompatible) class, + but passing $this. This is done for compatibility with php-4. */ + if (EX(fbc)->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { + zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); + } else { + /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name); } } + if ((EX(object) = EG(This))) { + Z_ADDREF_P(EX(object)); + EX(called_scope) = Z_OBJCE_P(EX(object)); + } + } - if (!zend_execute_internal) { - /* saves one function call if zend_execute_internal is not used */ - fbc->internal_function.handler(opline->extended_value, ret->var.ptr, (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) ? &ret->var.ptr : NULL, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} + +ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV) +{ + USE_OPLINE + zval *function_name; + zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); + + if (OP2_TYPE == IS_CONST) { + function_name = (zval*)(opline->op2.literal+1); + if (CACHED_PTR(opline->op2.literal->cache_slot)) { + EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); + } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &EX(fbc)) == FAILURE)) { + SAVE_OPLINE(); + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); } else { - zend_execute_internal(EXECUTE_DATA, RETURN_VALUE_USED(opline) TSRMLS_CC); + CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); } + EX(object) = NULL; + /*CHECK_EXCEPTION();*/ + ZEND_VM_NEXT_OPCODE(); + } else { + char *function_name_strval, *lcname; + int function_name_strlen; + zend_free_op free_op2; - if (!RETURN_VALUE_USED(opline)) { - zval_ptr_dtor(&ret->var.ptr); - } - } else if (fbc->type == ZEND_USER_FUNCTION) { - EX(original_return_value) = EG(return_value_ptr_ptr); - EG(active_symbol_table) = NULL; - EG(active_op_array) = &fbc->op_array; - EG(return_value_ptr_ptr) = NULL; - if (RETURN_VALUE_USED(opline)) { - temp_variable *ret = &EX_T(opline->result.var); + SAVE_OPLINE(); + function_name = GET_OP2_ZVAL_PTR(BP_VAR_R); + + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + function_name_strval = Z_STRVAL_P(function_name); + function_name_strlen = Z_STRLEN_P(function_name); + if (function_name_strval[0] == '\\') { + function_name_strlen -= 1; + lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen); + } else { + lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen); + } + if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &EX(fbc)) == FAILURE)) { + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval); + } + efree(lcname); + FREE_OP2(); + EX(object) = NULL; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else if (OP2_TYPE != IS_CONST && OP2_TYPE != IS_TMP_VAR && + EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT) && + Z_OBJ_HANDLER_P(function_name, get_closure) && + Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &EX(called_scope), &EX(fbc), &EX(object) TSRMLS_CC) == SUCCESS) { + if (EX(object)) { + Z_ADDREF_P(EX(object)); + } + if (OP2_TYPE == IS_VAR && OP2_FREE && + EX(fbc)->common.fn_flags & ZEND_ACC_CLOSURE) { + /* Delay closure destruction until its invocation */ + EX(fbc)->common.prototype = (zend_function*)function_name; + } else { + FREE_OP2(); + } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else if (OP2_TYPE != IS_CONST && + EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && + zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { + zend_class_entry *ce; + zval **method = NULL; + zval **obj = NULL; - ret->var.ptr = NULL; - EG(return_value_ptr_ptr) = &ret->var.ptr; - ret->var.ptr_ptr = &ret->var.ptr; - ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; - } + zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj); + zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method); - if (EXPECTED(zend_execute == execute)) { - if (EXPECTED(EG(exception) == NULL)) { - ZEND_VM_ENTER(); ++ if (!obj || !method) { ++ zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1"); + } - } else { - zend_execute(EG(active_op_array) TSRMLS_CC); - } + - EG(opline_ptr) = &EX(opline); - EG(active_op_array) = EX(op_array); - EG(return_value_ptr_ptr) = EX(original_return_value); - if (EG(active_symbol_table)) { - if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) { - zend_hash_destroy(EG(active_symbol_table)); - FREE_HASHTABLE(EG(active_symbol_table)); - } else { - /* clean before putting into the cache, since clean - could call dtors, which could use cached hash */ - zend_hash_clean(EG(active_symbol_table)); - *(++EG(symtable_cache_ptr)) = EG(active_symbol_table); + if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) { + zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object"); } - } - EG(active_symbol_table) = EX(symbol_table); - } else { /* ZEND_OVERLOADED_FUNCTION */ - MAKE_STD_ZVAL(EX_T(opline->result.var).var.ptr); - ZVAL_NULL(EX_T(opline->result.var).var.ptr); - - /* Not sure what should be done here if it's a static method */ - if (EXPECTED(EX(object) != NULL)) { - Z_OBJ_HT_P(EX(object))->call_method(fbc->common.function_name, opline->extended_value, EX_T(opline->result.var).var.ptr, &EX_T(opline->result.var).var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC); - } else { - zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object"); - } - if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { - efree((char*)fbc->common.function_name); - } - efree(fbc); + if (Z_TYPE_PP(method) != IS_STRING) { + zend_error_noreturn(E_ERROR, "Second array member is not a valid method"); + } - if (!RETURN_VALUE_USED(opline)) { - zval_ptr_dtor(&EX_T(opline->result.var).var.ptr); - } else { - Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr); - Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1); - EX_T(opline->result.var).var.fcall_returned_reference = 0; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } - } + if (Z_TYPE_PP(obj) == IS_STRING) { + ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC); + if (UNEXPECTED(ce == NULL)) { + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } + EX(called_scope) = ce; + EX(object) = NULL; - EX(function_state).function = (zend_function *) EX(op_array); - EX(function_state).arguments = NULL; + if (ce->get_static_method) { + EX(fbc) = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC); + } else { + EX(fbc) = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); + } + } else { + EX(object) = *obj; + ce = EX(called_scope) = Z_OBJCE_PP(obj); - if (should_change_scope) { - if (EG(This)) { - if (UNEXPECTED(EG(exception) != NULL) && IS_CTOR_CALL(EX(called_scope))) { - if (IS_CTOR_USED(EX(called_scope))) { - Z_DELREF_P(EG(This)); + EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); + if (UNEXPECTED(EX(fbc) == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), Z_STRVAL_PP(method)); } - if (Z_REFCOUNT_P(EG(This)) == 1) { - zend_object_store_ctor_failed(EG(This) TSRMLS_CC); + + if ((EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) != 0) { + EX(object) = NULL; + } else { + if (!PZVAL_IS_REF(EX(object))) { + Z_ADDREF_P(EX(object)); /* For $this pointer */ + } else { + zval *this_ptr; + ALLOC_ZVAL(this_ptr); + INIT_PZVAL_COPY(this_ptr, EX(object)); + zval_copy_ctor(this_ptr); + EX(object) = this_ptr; + } } } - zval_ptr_dtor(&EG(This)); + + if (UNEXPECTED(EX(fbc) == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method)); + } + FREE_OP2(); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } else { + zend_error_noreturn(E_ERROR, "Function name must be a string"); } - EG(This) = EX(current_this); - EG(scope) = EX(current_scope); - EG(called_scope) = EX(current_called_scope); } +} - EX(object) = EX(current_object); - EX(called_scope) = DECODE_CTOR(EX(called_scope)); - zend_vm_stack_clear_multiple(TSRMLS_C); +ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST) +{ + USE_OPLINE + zend_literal *func_name; - if (UNEXPECTED(EG(exception) != NULL)) { - zend_throw_exception_internal(NULL TSRMLS_CC); - if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) { - zval_ptr_dtor(&EX_T(opline->result.var).var.ptr); + zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(called_scope)); + + func_name = opline->op2.literal + 1; + if (CACHED_PTR(opline->op2.literal->cache_slot)) { + EX(fbc) = CACHED_PTR(opline->op2.literal->cache_slot); + } else if (zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &EX(fbc))==FAILURE) { + func_name++; + if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &EX(fbc))==FAILURE)) { + SAVE_OPLINE(); + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); + } else { + CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); } - HANDLE_EXCEPTION(); + } else { + CACHE_PTR(opline->op2.literal->cache_slot, EX(fbc)); } + EX(object) = NULL; ZEND_VM_NEXT_OPCODE(); }
« previous php.cvs (#70244) next »