zend_string *class_name = NULL;
if (Z_OBJ_HANDLER_P(expr, get_class_name)) {
- class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(expr, 0 TSRMLS_CC);
+ class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(Z_OBJ_P(expr), 0 TSRMLS_CC);
}
if (class_name) {
zend_printf("%s Object (", class_name->val);
int is_temp;
if (Z_OBJ_HANDLER_P(expr, get_class_name)) {
- class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(expr, 0 TSRMLS_CC);
+ class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(Z_OBJ_P(expr), 0 TSRMLS_CC);
}
if (class_name) {
ZEND_PUTS_EX(class_name->val);
#include "zend_hash.h"
#include "zend_llist.h"
-#define INTERNAL_FUNCTION_PARAMETERS zend_uint param_count, zval *return_value, zval *this_ptr, int return_value_used TSRMLS_DC
-#define INTERNAL_FUNCTION_PARAM_PASSTHRU param_count, return_value, this_ptr, return_value_used TSRMLS_CC
+#define INTERNAL_FUNCTION_PARAMETERS zend_uint param_count, zval *return_value TSRMLS_DC
+#define INTERNAL_FUNCTION_PARAM_PASSTHRU param_count, return_value TSRMLS_CC
+
+#define USED_RET() \
+ (!EG(current_execute_data) || \
+ !EG(current_execute_data)->opline || \
+ !(EG(current_execute_data)->opline->result_type & EXT_TYPE_UNUSED))
#if defined(__GNUC__) && __GNUC__ >= 3 && !defined(__INTEL_COMPILER) && !defined(DARWIN) && !defined(__hpux) && !defined(_AIX) && !defined(__osf__)
void zend_error_noreturn(int type, const char *format, ...) __attribute__ ((noreturn));
}
/* }}} */
-ZEND_API zend_class_entry *zend_get_class_entry(const zval *zobject TSRMLS_DC) /* {{{ */
+ZEND_API zend_class_entry *zend_get_class_entry(const zend_object *zobject TSRMLS_DC) /* {{{ */
{
- if (Z_OBJ_HT_P(zobject)->get_class_entry) {
- return Z_OBJ_HT_P(zobject)->get_class_entry(zobject TSRMLS_CC);
+ if (zobject->handlers->get_class_entry) {
+ return zobject->handlers->get_class_entry(zobject TSRMLS_CC);
} else {
zend_error(E_ERROR, "Class entry requested for an object without PHP class");
return NULL;
/* }}} */
/* returns 1 if you need to copy result, 0 if it's already a copy */
-ZEND_API zend_string *zend_get_object_classname(const zval *object TSRMLS_DC) /* {{{ */
+ZEND_API zend_string *zend_get_object_classname(const zend_object *object TSRMLS_DC) /* {{{ */
{
zend_string *ret;
- if (Z_OBJ_HT_P(object)->get_class_name != NULL) {
- ret = Z_OBJ_HT_P(object)->get_class_name(object, 0 TSRMLS_CC);
+ if (object->handlers->get_class_name != NULL) {
+ ret = object->handlers->get_class_name(object, 0 TSRMLS_CC);
if (ret) {
return ret;
}
}
- return Z_OBJCE_P(object)->name;
+ return zend_get_class_entry(object TSRMLS_CC)->name;
}
/* }}} */
} else {
fcc->called_scope = EG(called_scope);
fcc->calling_scope = EG(scope);
- if (Z_TYPE(fcc->object) == IS_UNDEF && Z_TYPE(EG(This)) == IS_OBJECT) {
- ZVAL_COPY_VALUE(&fcc->object, &EG(This));
+ if (!fcc->object && Z_OBJ(EG(This))) {
+ fcc->object = Z_OBJ(EG(This));
}
ret = 1;
}
} else {
fcc->called_scope = EG(called_scope);
fcc->calling_scope = EG(scope)->parent;
- if (Z_TYPE(fcc->object) == IS_UNDEF && Z_TYPE(EG(This)) == IS_OBJECT) {
- ZVAL_COPY_VALUE(&fcc->object, &EG(This));
+ if (!fcc->object && Z_OBJ(EG(This))) {
+ fcc->object = Z_OBJ(EG(This));
}
*strict_class = 1;
ret = 1;
} else {
fcc->called_scope = EG(called_scope);
fcc->calling_scope = EG(called_scope);
- if (Z_TYPE(fcc->object) == IS_UNDEF && Z_TYPE(EG(This)) == IS_OBJECT) {
- ZVAL_COPY_VALUE(&fcc->object, &EG(This));
+ if (!fcc->object && Z_OBJ(EG(This))) {
+ fcc->object = Z_OBJ(EG(This));
}
*strict_class = 1;
ret = 1;
zend_class_entry *scope = EG(active_op_array) ? EG(active_op_array)->scope : NULL;
fcc->calling_scope = ce;
- if (scope && Z_TYPE(fcc->object) == IS_UNDEF && Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (scope && !fcc->object && Z_OBJ(EG(This)) &&
instanceof_function(Z_OBJCE(EG(This)), scope TSRMLS_CC) &&
instanceof_function(scope, fcc->calling_scope TSRMLS_CC)) {
- ZVAL_COPY_VALUE(&fcc->object, &EG(This));
- fcc->called_scope = Z_OBJCE(fcc->object);
+ fcc->object = Z_OBJ(EG(This));
+ fcc->called_scope = Z_OBJCE(EG(This));
} else {
- fcc->called_scope = Z_TYPE(fcc->object) == IS_OBJECT ? Z_OBJCE(fcc->object) : fcc->calling_scope;
+ fcc->called_scope = fcc->object ? zend_get_class_entry(fcc->object TSRMLS_CC) : fcc->calling_scope;
}
*strict_class = 1;
ret = 1;
}
if ((check_flags & IS_CALLABLE_CHECK_NO_ACCESS) == 0 &&
(fcc->calling_scope &&
- ((Z_TYPE(fcc->object) == IS_OBJECT && fcc->calling_scope->__call) ||
- (Z_TYPE(fcc->object) == IS_UNDEF && fcc->calling_scope->__callstatic)))) {
+ ((fcc->object && fcc->calling_scope->__call) ||
+ (!fcc->object && fcc->calling_scope->__callstatic)))) {
if (fcc->function_handler->op_array.fn_flags & ZEND_ACC_PRIVATE) {
- if (!zend_check_private(fcc->function_handler, Z_TYPE(fcc->object) == IS_OBJECT ? Z_OBJCE(fcc->object) : EG(scope), lmname TSRMLS_CC)) {
+ if (!zend_check_private(fcc->function_handler, fcc->object ? zend_get_class_entry(fcc->object TSRMLS_CC) : EG(scope), lmname TSRMLS_CC)) {
retval = 0;
fcc->function_handler = NULL;
goto get_function_via_handler;
}
} else {
get_function_via_handler:
- if (Z_TYPE(fcc->object) == IS_OBJECT && fcc->calling_scope == ce_org) {
+ if (fcc->object && fcc->calling_scope == ce_org) {
if (strict_class && ce_org->__call) {
fcc->function_handler = emalloc(sizeof(zend_internal_function));
fcc->function_handler->internal_function.type = ZEND_INTERNAL_FUNCTION;
STR_ADDREF(mname);
call_via_handler = 1;
retval = 1;
- } else if (Z_OBJ_HT(fcc->object)->get_method) {
- fcc->function_handler = Z_OBJ_HT(fcc->object)->get_method(&fcc->object, mname, NULL TSRMLS_CC);
+ } else if (fcc->object->handlers->get_method) {
+ fcc->function_handler = fcc->object->handlers->get_method(&fcc->object, mname, NULL TSRMLS_CC);
if (fcc->function_handler) {
if (strict_class &&
(!fcc->function_handler->common.scope ||
if (fcc->function_handler) {
retval = 1;
call_via_handler = (fcc->function_handler->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) != 0;
- if (call_via_handler && Z_TYPE(fcc->object) == IS_UNDEF && Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (call_via_handler && !fcc->object && Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
instanceof_function(Z_OBJCE(EG(This)), fcc->calling_scope TSRMLS_CC)) {
- ZVAL_COPY_VALUE(&fcc->object, &EG(This));
+ fcc->object = Z_OBJ(EG(This));
}
}
}
if (retval) {
if (fcc->calling_scope && !call_via_handler) {
- if (Z_TYPE(fcc->object) == IS_UNDEF && (fcc->function_handler->common.fn_flags & ZEND_ACC_ABSTRACT)) {
+ if (!fcc->object && (fcc->function_handler->common.fn_flags & ZEND_ACC_ABSTRACT)) {
if (error) {
zend_spprintf(error, 0, "cannot call abstract method %s::%s()", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val);
retval = 0;
} else {
zend_error(E_ERROR, "Cannot call abstract method %s::%s()", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val);
}
- } else if (Z_TYPE(fcc->object) == IS_UNDEF && !(fcc->function_handler->common.fn_flags & ZEND_ACC_STATIC)) {
+ } else if (!fcc->object && !(fcc->function_handler->common.fn_flags & ZEND_ACC_STATIC)) {
int severity;
char *verb;
if (fcc->function_handler->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
if ((check_flags & IS_CALLABLE_CHECK_IS_STATIC) != 0) {
retval = 0;
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && instanceof_function(Z_OBJCE(EG(This)), fcc->calling_scope TSRMLS_CC)) {
- ZVAL_COPY_VALUE(&fcc->object, &EG(This));
+ if (Z_OBJ(EG(This)) && instanceof_function(Z_OBJCE(EG(This)), fcc->calling_scope TSRMLS_CC)) {
+ fcc->object = Z_OBJ(EG(This));
if (error) {
zend_spprintf(error, 0, "non-static method %s::%s() %s be called statically, assuming $this from compatible context %s", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val, verb, Z_OBJCE(EG(This))->name->val);
if (severity == E_ERROR) {
}
if (retval && (check_flags & IS_CALLABLE_CHECK_NO_ACCESS) == 0) {
if (fcc->function_handler->op_array.fn_flags & ZEND_ACC_PRIVATE) {
- if (!zend_check_private(fcc->function_handler, Z_TYPE(fcc->object) == IS_OBJECT ? Z_OBJCE(fcc->object) : EG(scope), lmname TSRMLS_CC)) {
+ if (!zend_check_private(fcc->function_handler, fcc->object ? zend_get_class_entry(fcc->object TSRMLS_CC) : EG(scope), lmname TSRMLS_CC)) {
if (error) {
if (*error) {
efree(*error);
STR_FREE(lmname);
STR_RELEASE(mname);
- if (Z_TYPE(fcc->object) == IS_OBJECT) {
- fcc->called_scope = Z_OBJCE(fcc->object);
+ if (fcc->object) {
+ fcc->called_scope = zend_get_class_entry(fcc->object TSRMLS_CC);
}
if (retval) {
fcc->initialized = 1;
}
/* }}} */
-ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint check_flags, zend_string **callable_name, zend_fcall_info_cache *fcc, char **error TSRMLS_DC) /* {{{ */
+ZEND_API zend_bool zend_is_callable_ex(zval *callable, zend_object *object, uint check_flags, zend_string **callable_name, zend_fcall_info_cache *fcc, char **error TSRMLS_DC) /* {{{ */
{
zend_bool ret;
zend_fcall_info_cache fcc_local;
fcc->called_scope = NULL;
fcc->function_handler = NULL;
fcc->calling_scope = NULL;
- ZVAL_UNDEF(&fcc->object);
+ fcc->object = NULL;
- if (object_ptr && Z_TYPE_P(object_ptr) != IS_OBJECT) {
- object_ptr = NULL;
- }
-
- if (object_ptr &&
+ if (object &&
(!EG(objects_store).object_buckets ||
- !IS_VALID(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(object_ptr)]))) {
+ !IS_VALID(EG(objects_store).object_buckets[object->handle]))) {
return 0;
}
switch (Z_TYPE_P(callable)) {
case IS_STRING:
- if (object_ptr) {
- ZVAL_COPY_VALUE(&fcc->object, object_ptr);
- fcc->calling_scope = Z_OBJCE_P(object_ptr);
+ if (object) {
+ fcc->object = object;
+ fcc->calling_scope = zend_get_class_entry(object TSRMLS_CC);
if (callable_name) {
char *ptr;
fcc->calling_scope = Z_OBJCE_P(obj); /* TBFixed: what if it's overloaded? */
- ZVAL_COPY_VALUE(&fcc->object, obj);
+ fcc->object = Z_OBJ_P(obj);
if (callable_name) {
char *ptr;
fci->size = sizeof(*fci);
fci->function_table = fcc->calling_scope ? &fcc->calling_scope->function_table : EG(function_table);
- fci->object_ptr = &fcc->object;
+ fci->object = fcc->object;
ZVAL_COPY_VALUE(&fci->function_name, callable);
fci->retval = NULL;
fci->param_count = 0;
EG(scope) = scope;
if (!Z_OBJ_HT_P(object)->write_property) {
- zend_string *class_name = zend_get_object_classname(object TSRMLS_CC);
+ zend_string *class_name = zend_get_object_classname(Z_OBJ_P(object) TSRMLS_CC);
zend_error(E_CORE_ERROR, "Property %s of class %s cannot be updated", name, class_name->val);
}
ZVAL_STRINGL(&property, name, name_length);
EG(scope) = scope;
if (!Z_OBJ_HT_P(object)->read_property) {
- zend_string *class_name = zend_get_object_classname(object TSRMLS_CC);
+ zend_string *class_name = zend_get_object_classname(Z_OBJ_P(object) TSRMLS_CC);
zend_error(E_CORE_ERROR, "Property %s of class %s cannot be read", name, class_name->val);
}
zval *retval;
zend_uint param_count;
zval *params;
- zval *object_ptr;
+ zend_object *object;
zend_bool no_separation;
} zend_fcall_info;
zend_function *function_handler;
zend_class_entry *calling_scope;
zend_class_entry *called_scope;
- zval object;
+ zend_object *object;
} zend_fcall_info_cache;
#define ZEND_NS_NAME(ns, name) ns "\\" name
#define IS_CALLABLE_STRICT (IS_CALLABLE_CHECK_IS_STATIC)
-ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint check_flags, zend_string **callable_name, zend_fcall_info_cache *fcc, char **error TSRMLS_DC);
+ZEND_API zend_bool zend_is_callable_ex(zval *callable, zend_object *object, uint check_flags, zend_string **callable_name, zend_fcall_info_cache *fcc, char **error TSRMLS_DC);
ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, zend_string **callable_name TSRMLS_DC);
ZEND_API zend_bool zend_make_callable(zval *callable, zend_string **callable_name TSRMLS_DC);
ZEND_API const char *zend_get_module_version(const char *module_name);
ZEND_API zval *zend_read_static_property(zend_class_entry *scope, const char *name, int name_length, zend_bool silent TSRMLS_DC);
-ZEND_API zend_class_entry *zend_get_class_entry(const zval *zobject TSRMLS_DC);
-ZEND_API zend_string *zend_get_object_classname(const zval *object TSRMLS_DC);
+ZEND_API zend_class_entry *zend_get_class_entry(const zend_object *object TSRMLS_DC);
+ZEND_API zend_string *zend_get_object_classname(const zend_object *object TSRMLS_DC);
ZEND_API char *zend_get_type_by_const(int type);
-#define getThis() (this_ptr)
+#define getThis() (Z_OBJ(EG(This)) ? &EG(This) : NULL)
#define WRONG_PARAM_COUNT ZEND_WRONG_PARAM_COUNT()
#define WRONG_PARAM_COUNT_WITH_RETVAL(ret) ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)
}
}
- RETURN_STR(zend_get_object_classname(obj TSRMLS_CC));
+ RETURN_STR(zend_get_object_classname(Z_OBJ_P(obj) TSRMLS_CC));
}
/* }}} */
if (Z_TYPE_P(arg) == IS_OBJECT) {
if (Z_OBJ_HT_P(arg)->get_class_name
- && (name = Z_OBJ_HT_P(arg)->get_class_name(arg, 1 TSRMLS_CC)) != NULL) {
+ && (name = Z_OBJ_HT_P(arg)->get_class_name(Z_OBJ_P(arg), 1 TSRMLS_CC)) != NULL) {
RETURN_STR(name);
} else {
- ce = zend_get_class_entry(arg TSRMLS_CC);
+ ce = zend_get_class_entry(Z_OBJ_P(arg) TSRMLS_CC);
}
} else if (Z_TYPE_P(arg) == IS_STRING) {
ce = zend_lookup_class(Z_STR_P(arg) TSRMLS_CC);
if (Z_TYPE_P(klass) == IS_OBJECT
&& Z_OBJ_HT_P(klass)->get_method != NULL
- && (func = Z_OBJ_HT_P(klass)->get_method(klass, method_name, NULL TSRMLS_CC)) != NULL
+ && (func = Z_OBJ_HT_P(klass)->get_method(&Z_OBJ_P(klass), method_name, NULL TSRMLS_CC)) != NULL
) {
if (func->type == ZEND_INTERNAL_FUNCTION
&& (func->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) != 0
function_name = (ptr->function_state.function->common.scope &&
ptr->function_state.function->common.scope->trait_aliases) ?
zend_resolve_method_name(
- Z_TYPE(ptr->object) != IS_UNDEF ?
- Z_OBJCE(ptr->object) :
+ ptr->object ?
+ zend_get_class_entry(ptr->object TSRMLS_CC) :
ptr->function_state.function->common.scope,
ptr->function_state.function)->val :
(ptr->function_state.function->common.function_name ?
NULL);
if (function_name) {
- if (Z_TYPE(ptr->object) != IS_UNDEF) {
+ if (ptr->object) {
if (ptr->function_state.function->common.scope) {
class_name = ptr->function_state.function->common.scope->name;
} else {
- class_name = zend_get_object_classname(&ptr->object TSRMLS_CC);
+ class_name = zend_get_object_classname(ptr->object TSRMLS_CC);
}
call_type = "->";
function_name = (ptr->function_state.function->common.scope &&
ptr->function_state.function->common.scope->trait_aliases) ?
zend_resolve_method_name(
- Z_TYPE(ptr->object) != IS_UNDEF ?
- Z_OBJCE(ptr->object) :
+ ptr->object ?
+ zend_get_class_entry(ptr->object TSRMLS_CC) :
ptr->function_state.function->common.scope,
ptr->function_state.function)->val :
(ptr->function_state.function->common.function_name ?
if (function_name) {
add_assoc_string_ex(&stack_frame, "function", sizeof("function")-1, (char*)function_name, 1);
- if (Z_TYPE(ptr->object) == IS_OBJECT) {
+ if (ptr->object) {
if (ptr->function_state.function->common.scope) {
add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, STR_COPY(ptr->function_state.function->common.scope->name));
} else {
- class_name = zend_get_object_classname(&ptr->object TSRMLS_CC);
+ class_name = zend_get_object_classname(ptr->object TSRMLS_CC);
add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, STR_COPY(class_name));
}
if ((options & DEBUG_BACKTRACE_PROVIDE_OBJECT) != 0) {
- add_assoc_zval_ex(&stack_frame, "object", sizeof("object")-1, &ptr->object);
- Z_ADDREF(ptr->object);
+ zval object;
+ ZVAL_OBJ(&object, ptr->object);
+ add_assoc_zval_ex(&stack_frame, "object", sizeof("object")-1, &object);
+ Z_ADDREF(object);
}
add_assoc_string_ex(&stack_frame, "type", sizeof("type")-1, "->", 1);
efree(arguments);
zend_error(E_RECOVERABLE_ERROR, "Cannot get arguments for calling closure");
RETVAL_FALSE;
- } else if (call_user_function_ex(CG(function_table), NULL, this_ptr, return_value, ZEND_NUM_ARGS(), arguments, 1, NULL TSRMLS_CC) == FAILURE) {
+ } else if (call_user_function_ex(CG(function_table), NULL, getThis(), return_value, ZEND_NUM_ARGS(), arguments, 1, NULL TSRMLS_CC) == FAILURE) {
RETVAL_FALSE;
}
efree(arguments);
}
/* }}} */
-static zend_function *zend_closure_get_constructor(zval *object TSRMLS_DC) /* {{{ */
+static zend_function *zend_closure_get_constructor(zend_object *object TSRMLS_DC) /* {{{ */
{
zend_error(E_RECOVERABLE_ERROR, "Instantiation of 'Closure' is not allowed");
return NULL;
}
/* }}} */
-ZEND_API zend_function *zend_get_closure_invoke_method(zval *obj TSRMLS_DC) /* {{{ */
+ZEND_API zend_function *zend_get_closure_invoke_method(zend_object *object TSRMLS_DC) /* {{{ */
{
- zend_closure *closure = (zend_closure *)Z_OBJ_P(obj);
+ zend_closure *closure = (zend_closure *)object;
zend_function *invoke = (zend_function*)emalloc(sizeof(zend_function));
invoke->common = closure->func.common;
}
/* }}} */
-static zend_function *zend_closure_get_method(zval *object_ptr, zend_string *method, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zend_function *zend_closure_get_method(zend_object **object, zend_string *method, const zend_literal *key TSRMLS_DC) /* {{{ */
{
zend_string *lc_name;
memcmp(lc_name->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
) {
STR_FREE(lc_name);
- return zend_get_closure_invoke_method(object_ptr TSRMLS_CC);
+ return zend_get_closure_invoke_method(*object TSRMLS_CC);
}
STR_FREE(lc_name);
- return std_object_handlers.get_method(object_ptr, method, key TSRMLS_CC);
+ return std_object_handlers.get_method(object, method, key TSRMLS_CC);
}
/* }}} */
}
/* }}} */
-int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zval *zobj_ptr TSRMLS_DC) /* {{{ */
+int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zend_object **obj_ptr TSRMLS_DC) /* {{{ */
{
zend_closure *closure;
*fptr_ptr = &closure->func;
if (Z_TYPE(closure->this_ptr) != IS_UNDEF) {
- if (zobj_ptr) {
- ZVAL_COPY_VALUE(zobj_ptr, &closure->this_ptr);
+ if (obj_ptr) {
+ *obj_ptr = Z_OBJ(closure->this_ptr);
}
*ce_ptr = Z_OBJCE(closure->this_ptr);
} else {
- if (zobj_ptr) {
- ZVAL_UNDEF(zobj_ptr);
+ if (obj_ptr) {
+ *obj_ptr = NULL;
}
*ce_ptr = closure->func.common.scope;
}
extern ZEND_API zend_class_entry *zend_ce_closure;
ZEND_API void zend_create_closure(zval *res, zend_function *op_array, zend_class_entry *scope, zval *this_ptr TSRMLS_DC);
-ZEND_API zend_function *zend_get_closure_invoke_method(zval *obj TSRMLS_DC);
+ZEND_API zend_function *zend_get_closure_invoke_method(zend_object *obj TSRMLS_DC);
ZEND_API const zend_function *zend_get_closure_method_def(zval *obj TSRMLS_DC);
ZEND_API zval* zend_get_closure_this_ptr(zval *obj TSRMLS_DC);
typedef struct _call_slot {
zend_function *fbc;
zend_class_entry *called_scope;
- zval object;
+ zend_object *object;
zend_uint num_additional_args;
zend_bool is_ctor_call;
zend_bool is_ctor_result_used;
struct _zend_op *opline;
zend_function_state function_state;
zend_op_array *op_array;
- zval object;
+ zend_object *object;
zend_array *symbol_table;
struct _zend_execute_data *prev_execute_data;
zval old_error_reporting;
//???
zend_class_entry *current_scope;
zend_class_entry *current_called_scope;
- zval current_this;
+ zend_object *current_this;
struct _zend_op *fast_ret; /* used by FAST_CALL/FAST_RET (finally keyword) */
zend_object *delayed_exception;
call_slot *call_slots;
}
}
-ZEND_API void dtrace_execute_internal(zend_execute_data *execute_data_ptr, zend_fcall_info *fci, int return_value_used TSRMLS_DC)
+ZEND_API void dtrace_execute_internal(zend_execute_data *execute_data_ptr, zend_fcall_info *fci TSRMLS_DC)
{
int lineno;
const char *filename;
DTRACE_EXECUTE_ENTRY((char *)filename, lineno);
}
- execute_internal(execute_data_ptr, fci, return_value_used TSRMLS_CC);
+ execute_internal(execute_data_ptr, fci TSRMLS_CC);
if (DTRACE_EXECUTE_RETURN_ENABLED()) {
DTRACE_EXECUTE_RETURN((char *)filename, lineno);
zend_uint name_len;
if (exception != NULL) {
- zend_get_object_classname(exception, &classname, &name_len TSRMLS_CC);
+ zend_get_object_classname(Z_OBJ_P(exception), &classname, &name_len TSRMLS_CC);
DTRACE_EXCEPTION_THROWN((char *)classname);
} else {
DTRACE_EXCEPTION_THROWN(NULL);
TRACE_APPEND_STR("Object(");
- class_name = zend_get_object_classname(arg TSRMLS_CC);
+ class_name = zend_get_object_classname(Z_OBJ_P(arg) TSRMLS_CC);
TRACE_APPEND_STRL(class_name->val, class_name->len);
//??? if(!dup) {
fci.function_table = &Z_OBJCE_P(exception)->function_table;
ZVAL_COPY_VALUE(&fci.function_name, &fname);
fci.symbol_table = NULL;
- fci.object_ptr = exception;
+ fci.object = Z_OBJ_P(exception);
fci.retval = &trace;
fci.param_count = 0;
fci.params = NULL;
static zend_always_inline zval *_get_obj_zval_ptr_unused(TSRMLS_D)
{
- if (EXPECTED(Z_TYPE(EG(This)) != IS_UNDEF)) {
+ if (EXPECTED(Z_OBJ(EG(This)) != NULL)) {
return &EG(This);
} else {
zend_error_noreturn(E_ERROR, "Using $this when not in object context");
static inline zval *_get_obj_zval_ptr(int op_type, znode_op *op, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC)
{
if (op_type == IS_UNUSED) {
- if (EXPECTED(Z_TYPE(EG(This)) != IS_UNDEF)) {
+ if (EXPECTED(Z_OBJ(EG(This)) != NULL)) {
should_free->var = NULL;
return &EG(This);
} else {
ZEND_API opcode_handler_t *zend_opcode_handlers;
-ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, zend_fcall_info *fci, int return_value_used TSRMLS_DC)
+ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, zend_fcall_info *fci TSRMLS_DC)
{
if (fci != NULL) {
execute_data_ptr->function_state.function->internal_function.handler(
- fci->param_count, fci->retval,
- fci->object_ptr, 1 TSRMLS_CC
+ fci->param_count, fci->retval TSRMLS_CC
);
} else {
zval *return_value = EX_VAR_2(execute_data_ptr, execute_data_ptr->opline->result.var);
execute_data_ptr->function_state.function->internal_function.handler(
- execute_data_ptr->opline->extended_value, return_value,
- &execute_data_ptr->object, return_value_used TSRMLS_CC
+ execute_data_ptr->opline->extended_value, return_value TSRMLS_CC
);
}
}
EG(argument_stack)->top = (zval*)zend_vm_stack_frame_base(execute_data);
- ZVAL_UNDEF(&EX(object));
- ZVAL_UNDEF(&EX(current_this));
+ EX(object) = NULL;
+ EX(current_this) = NULL;
ZVAL_UNDEF(&EX(old_error_reporting));
EX(symbol_table) = EG(active_symbol_table);
EX(call) = NULL;
zend_attach_symbol_table(TSRMLS_C);
}
- if (op_array->this_var != -1 && Z_TYPE(EG(This)) != IS_UNDEF) {
+ if (op_array->this_var != -1 && Z_OBJ(EG(This))) {
ZVAL_COPY(EX_VAR(op_array->this_var), &EG(This));
}
BEGIN_EXTERN_C()
struct _zend_fcall_info;
ZEND_API extern void (*zend_execute_ex)(zend_execute_data *execute_data TSRMLS_DC);
-ZEND_API extern void (*zend_execute_internal)(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci, int return_value_used TSRMLS_DC);
+ZEND_API extern void (*zend_execute_internal)(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci TSRMLS_DC);
void init_executor(TSRMLS_D);
void shutdown_executor(TSRMLS_D);
ZEND_API zend_execute_data *zend_create_execute_data_from_op_array(zend_op_array *op_array, zval *return_value, zend_bool nested TSRMLS_DC);
ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value TSRMLS_DC);
ZEND_API void execute_ex(zend_execute_data *execute_data TSRMLS_DC);
-ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci, int return_value_used TSRMLS_DC);
+ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci TSRMLS_DC);
ZEND_API int zend_is_true(zval *op TSRMLS_DC);
ZEND_API zend_class_entry *zend_lookup_class(zend_string *name TSRMLS_DC);
ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zend_literal *key, int use_autoload TSRMLS_DC);
/* The following tries to resolve the classname of a zval of type object.
* Since it is slow it should be only used in error messages.
*/
-#define Z_OBJ_CLASS_NAME_P(zval) ((zval) && Z_TYPE_P(zval) == IS_OBJECT && Z_OBJ_HT_P(zval)->get_class_entry != NULL && Z_OBJ_HT_P(zval)->get_class_entry(zval TSRMLS_CC) ? Z_OBJ_HT_P(zval)->get_class_entry(zval TSRMLS_CC)->name->val : "")
+#define Z_OBJ_CLASS_NAME_P(obj) (((obj) && (obj)->handlers->get_class_entry != NULL && (obj)->handlers->get_class_entry) ? (obj)->handlers->get_class_entry(obj TSRMLS_CC)->name->val : "")
ZEND_API zval* zend_get_compiled_variable_value(const zend_execute_data *execute_data_ptr, zend_uint var);
#endif
ZEND_API void (*zend_execute_ex)(zend_execute_data *execute_data TSRMLS_DC);
-ZEND_API void (*zend_execute_internal)(zend_execute_data *execute_data_ptr, zend_fcall_info *fci, int return_value_used TSRMLS_DC);
+ZEND_API void (*zend_execute_internal)(zend_execute_data *execute_data_ptr, zend_fcall_info *fci TSRMLS_DC);
/* true globals */
ZEND_API const zend_fcall_info empty_fcall_info = { 0, NULL, {{0},0}, NULL, NULL, 0, NULL, NULL, 0 };
-ZEND_API const zend_fcall_info_cache empty_fcall_info_cache = { 0, NULL, NULL, NULL, {{0},0} };
+ZEND_API const zend_fcall_info_cache empty_fcall_info_cache = { 0, NULL, NULL, NULL, NULL };
#ifdef ZEND_WIN32
#include <process.h>
EG(scope) = NULL;
EG(called_scope) = NULL;
- ZVAL_UNDEF(&EG(This));
+ ZVAL_OBJ(&EG(This), NULL);
EG(active_op_array) = NULL;
}
/* }}} */
-static int zend_unclean_zval_ptr_dtor(zval *zv) /* {{{ */
+static void zend_unclean_zval_ptr_dtor(zval *zv) /* {{{ */
{
TSRMLS_FETCH();
fci.size = sizeof(fci);
fci.function_table = function_table;
- fci.object_ptr = object;
+ fci.object = object ? Z_OBJ_P(object) : NULL;
ZVAL_COPY_VALUE(&fci.function_name, function_name);
fci.retval = retval_ptr;
fci.param_count = param_count;
zend_class_entry *current_called_scope;
zend_class_entry *calling_scope = NULL;
zend_class_entry *called_scope = NULL;
- zval current_this;
+ zend_object *current_this;
zend_execute_data execute_data;
zend_fcall_info_cache fci_cache_local;
zval tmp;
execute_data = *EG(current_execute_data);
EX(op_array) = NULL;
EX(opline) = NULL;
- ZVAL_UNDEF(&EX(object));
+ EX(object) = NULL;
} else {
/* This only happens when we're called outside any execute()'s
* It shouldn't be strictly necessary to NULL execute_data out,
fci_cache = &fci_cache_local;
}
- if (!zend_is_callable_ex(&fci->function_name, fci->object_ptr, IS_CALLABLE_CHECK_SILENT, &callable_name, fci_cache, &error TSRMLS_CC)) {
+ if (!zend_is_callable_ex(&fci->function_name, fci->object, IS_CALLABLE_CHECK_SILENT, &callable_name, fci_cache, &error TSRMLS_CC)) {
if (error) {
zend_error(E_WARNING, "Invalid callback %s, %s", callable_name->val, error);
efree(error);
EX(function_state).function = fci_cache->function_handler;
calling_scope = fci_cache->calling_scope;
called_scope = fci_cache->called_scope;
- fci->object_ptr = &fci_cache->object;
- ZVAL_COPY_VALUE(&EX(object), fci->object_ptr);
- if (fci->object_ptr && Z_TYPE_P(fci->object_ptr) == IS_OBJECT &&
+ EX(object) = fci->object = fci_cache->object;
+ if (fci->object &&
(!EG(objects_store).object_buckets ||
- !IS_VALID(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(fci->object_ptr)]))) {
+ !IS_VALID(EG(objects_store).object_buckets[fci->object->handle]))) {
return FAILURE;
}
current_scope = EG(scope);
EG(scope) = calling_scope;
- ZVAL_COPY_VALUE(¤t_this, &EG(This));
+ current_this = Z_OBJ(EG(This));
current_called_scope = EG(called_scope);
if (called_scope) {
EG(called_scope) = NULL;
}
- if (fci->object_ptr) {
- if ((EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC)) {
- ZVAL_UNDEF(&EG(This));
- } else {
- ZVAL_COPY(&EG(This), fci->object_ptr);
- }
+ if (!fci->object ||
+ (EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC)) {
+ Z_OBJ(EG(This)) = NULL;
} else {
- ZVAL_UNDEF(&EG(This));
+ Z_OBJ(EG(This)) = fci->object;
+ Z_ADDREF(EG(This));
}
EX(prev_execute_data) = EG(current_execute_data);
}
if (EXPECTED(zend_execute_internal == NULL)) {
/* saves one function call if zend_execute_internal is not used */
- EX(function_state).function->internal_function.handler(fci->param_count, fci->retval, fci->object_ptr, 1 TSRMLS_CC);
+ EX(function_state).function->internal_function.handler(fci->param_count, fci->retval TSRMLS_CC);
} else {
- zend_execute_internal(&execute_data, fci, 1 TSRMLS_CC);
+ zend_execute_internal(&execute_data, fci TSRMLS_CC);
}
/* We shouldn't fix bad extensions here,
because it can break proper ones (Bug #34045)
//??? ALLOC_INIT_ZVAL(*fci->retval_ptr_ptr);
/* Not sure what should be done here if it's a static method */
- if (fci->object_ptr) {
- Z_OBJ_HT_P(fci->object_ptr)->call_method(EX(function_state).function->common.function_name, fci->param_count, fci->retval, fci->object_ptr, 1 TSRMLS_CC);
+ if (fci->object) {
+ fci->object->handlers->call_method(EX(function_state).function->common.function_name, fci->object, fci->param_count, fci->retval TSRMLS_CC);
} else {
zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
}
}
zend_vm_stack_clear_multiple(0 TSRMLS_CC);
- zval_ptr_dtor(&EG(This));
+ if (Z_OBJ(EG(This))) {
+ zval_ptr_dtor(&EG(This));
+ }
EG(called_scope) = current_called_scope;
EG(scope) = current_scope;
- ZVAL_COPY_VALUE(&EG(This), ¤t_this);
+ Z_OBJ(EG(This)) = current_this;
EG(current_execute_data) = EX(prev_execute_data);
if (EG(exception)) {
fcall_info.retval = &local_retval;
fcall_info.param_count = 1;
fcall_info.params = args;
- fcall_info.object_ptr = NULL;
+ fcall_info.object = NULL;
fcall_info.no_separation = 1;
fcall_cache.initialized = EG(autoload_func) ? 1 : 0;
fcall_cache.function_handler = EG(autoload_func);
fcall_cache.calling_scope = NULL;
fcall_cache.called_scope = NULL;
- ZVAL_UNDEF(&fcall_cache.object);
+ fcall_cache.object = NULL;
zend_exception_save(TSRMLS_C);
retval = zend_call_function(&fcall_info, &fcall_cache TSRMLS_CC);
if (ex->op_array->this_var != -1 &&
Z_TYPE_P(EX_VAR_2(ex, ex->op_array->this_var)) == IS_UNDEF &&
- Z_TYPE(EG(This)) != IS_UNDEF) {
+ Z_OBJ(EG(This))) {
ZVAL_COPY_VALUE(EX_VAR_2(ex, ex->op_array->this_var), &EG(This));
}
for (i = 0; i < ex->op_array->last_var; i++) {
return FAILURE;
}
} else {
- return zend_hash_str_update_ind(&EG(active_symbol_table)->ht, name, len, value);
+ return (zend_hash_str_update_ind(&EG(active_symbol_table)->ht, name, len, value) != NULL) ? SUCCESS : FAILURE;
}
return SUCCESS;
}
/* If yield was used as a function argument there may be active
* method calls those objects need to be freed */
while (execute_data->call >= execute_data->call_slots) {
- zval_ptr_dtor(&execute_data->call->object);
+ if (execute_data->call->object) {
+ OBJ_RELEASE(execute_data->call->object);
+ }
execute_data->call--;
}
}
zend_clean_and_cache_symbol_table(execute_data->symbol_table TSRMLS_CC);
}
- zval_ptr_dtor(&execute_data->current_this);
+ if (execute_data->current_this) {
+ OBJ_RELEASE(execute_data->current_this);
+ }
/* A fatal error / die occurred during the generator execution. Trying to clean
* up the stack may not be safe in this case. */
object_init_ex(return_value, zend_ce_generator);
- if (Z_TYPE(EG(This)) != IS_UNDEF) {
+ if (Z_OBJ(EG(This))) {
Z_ADDREF(EG(This));
}
execute_data->current_scope = EG(scope);
execute_data->current_called_scope = EG(called_scope);
execute_data->symbol_table = EG(active_symbol_table);
- ZVAL_COPY_VALUE(&execute_data->current_this, &EG(This));
+ execute_data->current_this = Z_OBJ(EG(This));
/* Save execution context in generator object. */
generator = (zend_generator *) Z_OBJ_P(return_value);
}
/* }}} */
-static zend_function *zend_generator_get_constructor(zval *object TSRMLS_DC) /* {{{ */
+static zend_function *zend_generator_get_constructor(zend_object *object TSRMLS_DC) /* {{{ */
{
zend_error(E_RECOVERABLE_ERROR, "The \"Generator\" class is reserved for internal use and cannot be manually instantiated");
zend_op **original_opline_ptr = EG(opline_ptr);
zend_op_array *original_active_op_array = EG(active_op_array);
zend_array *original_active_symbol_table = EG(active_symbol_table);
- zval original_This;
+ zend_object *original_This;
zend_class_entry *original_scope = EG(scope);
zend_class_entry *original_called_scope = EG(called_scope);
zend_vm_stack original_stack = EG(argument_stack);
- ZVAL_COPY_VALUE(&original_This, &EG(This));
+ original_This = Z_OBJ(EG(This));
/* Set executor globals */
EG(current_execute_data) = generator->execute_data;
EG(opline_ptr) = &generator->execute_data->opline;
EG(active_op_array) = generator->execute_data->op_array;
EG(active_symbol_table) = generator->execute_data->symbol_table;
- ZVAL_COPY_VALUE(&EG(This), &generator->execute_data->current_this);
+ Z_OBJ(EG(This)) = generator->execute_data->current_this;
EG(scope) = generator->execute_data->current_scope;
EG(called_scope) = generator->execute_data->current_called_scope;
EG(argument_stack) = generator->stack;
EG(opline_ptr) = original_opline_ptr;
EG(active_op_array) = original_active_op_array;
EG(active_symbol_table) = original_active_symbol_table;
- EG(This) = original_This;
+ Z_OBJ(EG(This)) = original_This;
EG(scope) = original_scope;
EG(called_scope) = original_called_scope;
EG(argument_stack) = original_stack;
fci.size = sizeof(fci);
/*fci.function_table = NULL; will be read form zend_class_entry of object if needed */
- fci.object_ptr = object;
+ fci.object = (object && Z_TYPE_P(object) == IS_OBJECT) ? Z_OBJ_P(object) : NULL;
ZVAL_STRINGL(&fci.function_name, function_name, function_name_len);
fci.retval = retval_ptr ? retval_ptr : &retval;
fci.param_count = param_count;
} else {
fcic.called_scope = EG(called_scope);
}
- if (object) {
- ZVAL_COPY_VALUE(&fcic.object, object);
- } else {
- ZVAL_UNDEF(&fcic.object);
- }
+ fcic.object = object ? Z_OBJ_P(object) : NULL;
result = zend_call_function(&fci, &fcic TSRMLS_CC);
zval_ptr_dtor(&fci.function_name);
}
zend_internal_function *func = (zend_internal_function *)EG(current_execute_data)->function_state.function;
zval method_name, method_args;
zval method_result;
- zend_class_entry *ce = Z_OBJCE_P(this_ptr);
+ zend_class_entry *ce = Z_OBJCE_P(getThis());
array_init_size(&method_args, ZEND_NUM_ARGS());
*/
ZVAL_UNDEF(&method_result);
- zend_call_method_with_2_params(this_ptr, ce, &ce->__call, ZEND_CALL_FUNC_NAME, &method_result, &method_name, &method_args);
+ zend_call_method_with_2_params(getThis(), ce, &ce->__call, ZEND_CALL_FUNC_NAME, &method_result, &method_name, &method_args);
if (Z_TYPE(method_result) != IS_UNDEF) {
RETVAL_ZVAL_FAST(&method_result);
}
/* }}} */
-static union _zend_function *zend_std_get_method(zval *object, zend_string *method_name, const zend_literal *key TSRMLS_DC) /* {{{ */
+static union _zend_function *zend_std_get_method(zend_object **obj_ptr, zend_string *method_name, const zend_literal *key TSRMLS_DC) /* {{{ */
{
+ zend_object *zobj = *obj_ptr;
zval *func;
zend_function *fbc;
- zend_object *zobj = Z_OBJ_P(object);
zend_string *lc_method_name;
if (EXPECTED(key != NULL)) {
/* 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 TSRMLS_CC);
+ updated_fbc = zend_check_private_int(fbc, zobj->handlers->get_class_entry(zobj TSRMLS_CC), lc_method_name TSRMLS_CC);
if (EXPECTED(updated_fbc != NULL)) {
fbc = updated_fbc;
} else {
STR_FREE(lc_function_name);
}
if (ce->__call &&
- Z_TYPE(EG(This)) == IS_OBJECT &&
+ Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
return zend_get_user_call_function(ce, function_name);
}
/* }}} */
-ZEND_API union _zend_function *zend_std_get_constructor(zval *object TSRMLS_DC) /* {{{ */
+ZEND_API union _zend_function *zend_std_get_constructor(zend_object *zobj TSRMLS_DC) /* {{{ */
{
- zend_object *zobj = Z_OBJ_P(object);
zend_function *constructor = zobj->ce->constructor;
if (constructor) {
}
/* }}} */
-zend_class_entry *zend_std_object_get_class(const zval *object TSRMLS_DC) /* {{{ */
+zend_class_entry *zend_std_object_get_class(const zend_object *object TSRMLS_DC) /* {{{ */
{
- zend_object *zobj;
- zobj = Z_OBJ_P(object);
-
- return zobj->ce;
+ return object->ce;
}
/* }}} */
-zend_string* zend_std_object_get_class_name(const zval *object, int parent TSRMLS_DC) /* {{{ */
+zend_string* zend_std_object_get_class_name(const zend_object *zobj, int parent TSRMLS_DC) /* {{{ */
{
- zend_object *zobj;
zend_class_entry *ce;
- zobj = Z_OBJ_P(object);
if (parent) {
if (!zobj->ce->parent) {
}
/* }}} */
-int zend_std_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zval *zobj_ptr TSRMLS_DC) /* {{{ */
+int zend_std_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zend_object **obj_ptr TSRMLS_DC) /* {{{ */
{
zval *func;
zend_class_entry *ce;
*ce_ptr = ce;
if ((*fptr_ptr)->common.fn_flags & ZEND_ACC_STATIC) {
- if (zobj_ptr) {
- ZVAL_UNDEF(zobj_ptr);
+ if (obj_ptr) {
+ *obj_ptr = NULL;
}
} else {
- if (zobj_ptr) {
- ZVAL_COPY_VALUE(zobj_ptr, obj);
+ if (obj_ptr) {
+ *obj_ptr = Z_OBJ_P(obj);
}
}
return SUCCESS;
/* args on stack! */
/* Andi - EX(fbc) (function being called) needs to be initialized already in the INIT fcall opcode so that the parameters can be parsed the right way. We need to add another callback for this.
*/
-typedef int (*zend_object_call_method_t)(zend_string *method, INTERNAL_FUNCTION_PARAMETERS);
-typedef union _zend_function *(*zend_object_get_method_t)(zval *object_ptr, zend_string *method, const struct _zend_literal *key TSRMLS_DC);
-typedef union _zend_function *(*zend_object_get_constructor_t)(zval *object TSRMLS_DC);
+typedef int (*zend_object_call_method_t)(zend_string *method, zend_object *object, INTERNAL_FUNCTION_PARAMETERS);
+typedef union _zend_function *(*zend_object_get_method_t)(zend_object **object, zend_string *method, const struct _zend_literal *key TSRMLS_DC);
+typedef union _zend_function *(*zend_object_get_constructor_t)(zend_object *object TSRMLS_DC);
/* Object maintenance/destruction */
-typedef void (*zend_object_add_ref_t)(zval *object TSRMLS_DC);
-typedef void (*zend_object_del_ref_t)(zval *object TSRMLS_DC);
-typedef void (*zend_object_delete_obj_t)(zval *object TSRMLS_DC);
typedef void (*zend_object_dtor_obj_t)(zend_object *object TSRMLS_DC);
typedef void (*zend_object_free_obj_t)(zend_object *object TSRMLS_DC);
typedef zend_object* (*zend_object_clone_obj_t)(zval *object TSRMLS_DC);
-typedef zend_class_entry *(*zend_object_get_class_entry_t)(const zval *object TSRMLS_DC);
-typedef zend_string *(*zend_object_get_class_name_t)(const zval *object, int parent TSRMLS_DC);
+typedef zend_class_entry *(*zend_object_get_class_entry_t)(const zend_object *object TSRMLS_DC);
+typedef zend_string *(*zend_object_get_class_name_t)(const zend_object *object, int parent TSRMLS_DC);
typedef int (*zend_object_compare_t)(zval *object1, zval *object2 TSRMLS_DC);
typedef int (*zend_object_compare_zvals_t)(zval *resul, zval *op1, zval *op2 TSRMLS_DC);
* Returns FAILURE if the object does not have any sense of overloaded dimensions */
typedef int (*zend_object_count_elements_t)(zval *object, long *count TSRMLS_DC);
-typedef int (*zend_object_get_closure_t)(zval *obj, zend_class_entry **ce_ptr, union _zend_function **fptr_ptr, zval *zobj_ptr TSRMLS_DC);
+typedef int (*zend_object_get_closure_t)(zval *obj, zend_class_entry **ce_ptr, union _zend_function **fptr_ptr, zend_object **obj_ptr TSRMLS_DC);
typedef HashTable *(*zend_object_get_gc_t)(zval *object, zval **table, int *n TSRMLS_DC);
ZEND_API union _zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name_strval, const struct _zend_literal *key TSRMLS_DC);
ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, zend_bool silent, const struct _zend_literal *key TSRMLS_DC);
ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name, const struct _zend_literal *key TSRMLS_DC);
-ZEND_API union _zend_function *zend_std_get_constructor(zval *object TSRMLS_DC);
+ZEND_API union _zend_function *zend_std_get_constructor(zend_object *object TSRMLS_DC);
ZEND_API struct _zend_property_info *zend_get_property_info(zend_class_entry *ce, zval *member, int silent TSRMLS_DC);
ZEND_API HashTable *zend_std_get_properties(zval *object TSRMLS_DC);
ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp TSRMLS_DC);
}
/* Called when the ctor was terminated by an exception */
-ZEND_API void zend_object_store_ctor_failed(zval *zobject TSRMLS_DC)
+ZEND_API void zend_object_store_ctor_failed(zend_object *obj TSRMLS_DC)
{
- zend_object *obj = Z_OBJ_P(zobject);
-
obj->gc.u.v.flags |= IS_OBJ_DESTRUCTOR_CALLED;
}
/* See comment in zend_objects_API.c before you use this */
ZEND_API void zend_object_store_set_object(zval *zobject, zend_object *object TSRMLS_DC);
-ZEND_API void zend_object_store_ctor_failed(zval *zobject TSRMLS_DC);
+ZEND_API void zend_object_store_ctor_failed(zend_object *object TSRMLS_DC);
ZEND_API void zend_objects_store_free_object_storage(zend_objects_store *objects TSRMLS_DC);
#define Z_OBJ_HANDLE(zval) (Z_OBJ((zval)))->handle
#define Z_OBJ_HANDLE_P(zval_p) Z_OBJ_HANDLE(*(zval_p))
-#define Z_OBJCE(zval) zend_get_class_entry(&(zval) TSRMLS_CC)
+#define Z_OBJCE(zval) zend_get_class_entry(Z_OBJ(zval) TSRMLS_CC)
#define Z_OBJCE_P(zval_p) Z_OBJCE(*(zval_p))
#define Z_OBJPROP(zval) Z_OBJ_HT((zval))->get_properties(&(zval) TSRMLS_CC)
EX(function_state).function = (zend_function *) EX(op_array);
EX(function_state).arguments = NULL;
- if (Z_TYPE(EG(This)) != IS_UNDEF) {
+ if (Z_OBJ(EG(This))) {
if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
if (EX(call)->is_ctor_result_used) {
Z_DELREF(EG(This));
}
if (Z_REFCOUNT(EG(This)) == 1) {
- zend_object_store_ctor_failed(&EG(This) TSRMLS_CC);
+ zend_object_store_ctor_failed(Z_OBJ(EG(This)) TSRMLS_CC);
}
}
zval_ptr_dtor(&EG(This));
}
- ZVAL_COPY_VALUE(&EG(This), &EX(current_this));
+ Z_OBJ(EG(This)) = EX(current_this);
EG(scope) = EX(current_scope);
EG(called_scope) = EX(current_called_scope);
zend_uint num_args;
SAVE_OPLINE();
- ZVAL_COPY_VALUE(&EX(object), &EX(call)->object);
+ EX(object) = EX(call)->object;
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->val, fbc->common.function_name->val);
}
if (fbc->common.scope &&
!(fbc->common.fn_flags & ZEND_ACC_STATIC) &&
- Z_TYPE(EX(object)) == IS_UNDEF) {
+ !EX(object)) {
if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
/* FIXME: output identifiers properly */
if (fbc->type == ZEND_USER_FUNCTION || fbc->common.scope) {
should_change_scope = 1;
- ZVAL_COPY_VALUE(&EX(current_this), &EG(This));
+ EX(current_this) = Z_OBJ(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 || Z_TYPE(EX(object)) == IS_UNDEF) ? fbc->common.scope : NULL;
+ Z_OBJ(EG(This)) = EX(object);
+//??? EG(scope) = (fbc->type == ZEND_USER_FUNCTION || !EX(object)) ? fbc->common.scope : NULL;
+ EG(scope) = fbc->common.scope;
EG(called_scope) = EX(call)->called_scope;
}
- num_args = opline->extended_value + EX(call)->num_additional_args;
- if (EX(call)->num_additional_args) {
+ if (UNEXPECTED(EX(call)->num_additional_args != 0)) {
+ num_args = opline->extended_value + EX(call)->num_additional_args;
EX(function_state).arguments = zend_vm_stack_push_args(num_args TSRMLS_CC);
} else {
zval tmp;
+ num_args = opline->extended_value;
ZVAL_LONG(&tmp, num_args);
EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C);
zend_vm_stack_push(&tmp TSRMLS_CC);
if (!zend_execute_internal) {
/* saves one function call if zend_execute_internal is not used */
- fbc->internal_function.handler(num_args, ret, &EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
+ fbc->internal_function.handler(num_args, ret TSRMLS_CC);
} else {
- zend_execute_internal(execute_data, NULL, RETURN_VALUE_USED(opline) TSRMLS_CC);
+ zend_execute_internal(execute_data, NULL TSRMLS_CC);
}
if (!RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
/* Not sure what should be done here if it's a static method */
- if (EXPECTED(Z_TYPE(EX(object)) != IS_UNDEF)) {
- Z_OBJ_HT_P(&EX(object))->call_method(fbc->common.function_name, num_args, EX_VAR(opline->result.var), &EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
+ if (EXPECTED(EX(object) != NULL)) {
+ EX(object)->handlers->call_method(fbc->common.function_name, EX(object), num_args, EX_VAR(opline->result.var) TSRMLS_CC);
} else {
zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
}
EX(function_state).arguments = NULL;
if (should_change_scope) {
- if (Z_TYPE(EG(This)) != IS_UNDEF) {
+ if (Z_OBJ(EG(This))) {
if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
if (EX(call)->is_ctor_result_used) {
Z_DELREF(EG(This));
}
if (Z_REFCOUNT(EG(This)) == 1) {
- zend_object_store_ctor_failed(&EG(This) TSRMLS_CC);
+ zend_object_store_ctor_failed(Z_OBJ(EG(This)) TSRMLS_CC);
}
}
zval_ptr_dtor(&EG(This));
}
- ZVAL_COPY_VALUE(&EG(This), &EX(current_this));
+ Z_OBJ(EG(This)) = EX(current_this);
EG(scope) = EX(current_scope);
EG(called_scope) = EX(current_called_scope);
}
}
object = GET_OP1_OBJ_ZVAL_PTR_DEREF(BP_VAR_R);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (OP2_TYPE != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (OP2_TYPE == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
if (UNEXPECTED(ce->constructor == NULL)) {
zend_error_noreturn(E_ERROR, "Cannot call constructor");
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+ if (Z_OBJ(EG(This)) && Z_OBJCE(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->val);
}
call->fbc = ce->constructor;
}
if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- if (Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
!instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
/* We are calling method of the other (incompatible) class,
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
}
}
- ZVAL_COPY(&call->object, &EG(This));
+ call->object = Z_OBJ(EG(This));
+ if (call->object) {
+ call->object->gc.refcount++;
+ }
}
call->num_additional_args = 0;
CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
}
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
FREE_OP2();
call->fbc = Z_FUNC_P(func);
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
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, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
- if (Z_REFCOUNTED(call->object)) {
- Z_ADDREF(call->object);
+ if (call->object) {
+ call->object->gc.refcount++;
}
if (OP2_TYPE == IS_VAR && OP2_FREE && Z_REFCOUNT_P(function_name) == 1 &&
call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
}
if (Z_TYPE_P(obj) == IS_STRING) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC);
if (UNEXPECTED(call->called_scope == NULL)) {
CHECK_EXCEPTION();
}
} else {
call->called_scope = Z_OBJCE_P(obj);
- ZVAL_COPY_VALUE(&call->object, obj);
+ call->object = Z_OBJ_P(obj);
- call->fbc = Z_OBJ_HT_P(obj)->get_method(obj, Z_STR_P(method), NULL TSRMLS_CC);
+ call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(obj), Z_STRVAL_P(method));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method));
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
}
CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
}
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
}
call->fbc = EX(function_state).function;
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
}
}
object_init_ex(&object_zval, Z_CE_P(EX_VAR(opline->op1.var)));
- constructor = Z_OBJ_HT(object_zval)->get_constructor(&object_zval TSRMLS_CC);
+ constructor = Z_OBJ_HT(object_zval)->get_constructor(Z_OBJ(object_zval) TSRMLS_CC);
if (constructor == NULL) {
if (RETURN_VALUE_USED(opline)) {
/* We are not handling overloaded classes right now */
call->fbc = constructor;
- ZVAL_COPY_VALUE(&call->object, &object_zval);
+ call->object = Z_OBJ(object_zval);
call->called_scope = Z_CE_P(EX_VAR(opline->op1.var));
call->num_additional_args = 0;
call->is_ctor_call = 1;
}
EX(function_state).function = (zend_function *) new_op_array;
- ZVAL_UNDEF(&EX(object));
+ EX(object) = NULL;
if (!EG(active_symbol_table)) {
zend_rebuild_symbol_table(TSRMLS_C);
if (EX(call) >= EX(call_slots)) {
call_slot *call = EX(call);
do {
- if (Z_TYPE(call->object) != IS_UNDEF) {
+ if (call->object) {
if (call->is_ctor_call) {
if (call->is_ctor_result_used) {
- Z_DELREF(call->object);
+ call->object->gc.refcount--;
}
- if (Z_REFCOUNT(call->object) == 1) {
- zend_object_store_ctor_failed(&call->object TSRMLS_CC);
+ if (call->object->gc.refcount == 1) {
+ zend_object_store_ctor_failed(call->object TSRMLS_CC);
}
}
- zval_ptr_dtor(&call->object);
+ OBJ_RELEASE(call->object);
}
call--;
} while (call >= EX(call_slots));
zend_error_noreturn(E_ERROR, "Base lambda function for closure not found");
}
- zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc), EG(scope), &EG(This) TSRMLS_CC);
+ zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc), EG(scope), Z_OBJ(EG(This)) ? &EG(This) : NULL TSRMLS_CC);
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
EX(function_state).function = (zend_function *) EX(op_array);
EX(function_state).arguments = NULL;
- if (Z_TYPE(EG(This)) != IS_UNDEF) {
+ if (Z_OBJ(EG(This))) {
if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
if (EX(call)->is_ctor_result_used) {
Z_DELREF(EG(This));
}
if (Z_REFCOUNT(EG(This)) == 1) {
- zend_object_store_ctor_failed(&EG(This) TSRMLS_CC);
+ zend_object_store_ctor_failed(Z_OBJ(EG(This)) TSRMLS_CC);
}
}
zval_ptr_dtor(&EG(This));
}
- ZVAL_COPY_VALUE(&EG(This), &EX(current_this));
+ Z_OBJ(EG(This)) = EX(current_this);
EG(scope) = EX(current_scope);
EG(called_scope) = EX(current_called_scope);
zend_uint num_args;
SAVE_OPLINE();
- ZVAL_COPY_VALUE(&EX(object), &EX(call)->object);
+ EX(object) = EX(call)->object;
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->val, fbc->common.function_name->val);
}
if (fbc->common.scope &&
!(fbc->common.fn_flags & ZEND_ACC_STATIC) &&
- Z_TYPE(EX(object)) == IS_UNDEF) {
+ !EX(object)) {
if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
/* FIXME: output identifiers properly */
if (fbc->type == ZEND_USER_FUNCTION || fbc->common.scope) {
should_change_scope = 1;
- ZVAL_COPY_VALUE(&EX(current_this), &EG(This));
+ EX(current_this) = Z_OBJ(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 || Z_TYPE(EX(object)) == IS_UNDEF) ? fbc->common.scope : NULL;
+ Z_OBJ(EG(This)) = EX(object);
+//??? EG(scope) = (fbc->type == ZEND_USER_FUNCTION || !EX(object)) ? fbc->common.scope : NULL;
+ EG(scope) = fbc->common.scope;
EG(called_scope) = EX(call)->called_scope;
}
- num_args = opline->extended_value + EX(call)->num_additional_args;
- if (EX(call)->num_additional_args) {
+ if (UNEXPECTED(EX(call)->num_additional_args != 0)) {
+ num_args = opline->extended_value + EX(call)->num_additional_args;
EX(function_state).arguments = zend_vm_stack_push_args(num_args TSRMLS_CC);
} else {
zval tmp;
+ num_args = opline->extended_value;
ZVAL_LONG(&tmp, num_args);
EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C);
zend_vm_stack_push(&tmp TSRMLS_CC);
if (!zend_execute_internal) {
/* saves one function call if zend_execute_internal is not used */
- fbc->internal_function.handler(num_args, ret, &EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
+ fbc->internal_function.handler(num_args, ret TSRMLS_CC);
} else {
- zend_execute_internal(execute_data, NULL, RETURN_VALUE_USED(opline) TSRMLS_CC);
+ zend_execute_internal(execute_data, NULL TSRMLS_CC);
}
if (!RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
/* Not sure what should be done here if it's a static method */
- if (EXPECTED(Z_TYPE(EX(object)) != IS_UNDEF)) {
- Z_OBJ_HT_P(&EX(object))->call_method(fbc->common.function_name, num_args, EX_VAR(opline->result.var), &EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
+ if (EXPECTED(EX(object) != NULL)) {
+ EX(object)->handlers->call_method(fbc->common.function_name, EX(object), num_args, EX_VAR(opline->result.var) TSRMLS_CC);
} else {
zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
}
EX(function_state).arguments = NULL;
if (should_change_scope) {
- if (Z_TYPE(EG(This)) != IS_UNDEF) {
+ if (Z_OBJ(EG(This))) {
if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
if (EX(call)->is_ctor_result_used) {
Z_DELREF(EG(This));
}
if (Z_REFCOUNT(EG(This)) == 1) {
- zend_object_store_ctor_failed(&EG(This) TSRMLS_CC);
+ zend_object_store_ctor_failed(Z_OBJ(EG(This)) TSRMLS_CC);
}
}
zval_ptr_dtor(&EG(This));
}
- ZVAL_COPY_VALUE(&EG(This), &EX(current_this));
+ Z_OBJ(EG(This)) = EX(current_this);
EG(scope) = EX(current_scope);
EG(called_scope) = EX(current_called_scope);
}
}
}
object_init_ex(&object_zval, Z_CE_P(EX_VAR(opline->op1.var)));
- constructor = Z_OBJ_HT(object_zval)->get_constructor(&object_zval TSRMLS_CC);
+ constructor = Z_OBJ_HT(object_zval)->get_constructor(Z_OBJ(object_zval) TSRMLS_CC);
if (constructor == NULL) {
if (RETURN_VALUE_USED(opline)) {
/* We are not handling overloaded classes right now */
call->fbc = constructor;
- ZVAL_COPY_VALUE(&call->object, &object_zval);
+ call->object = Z_OBJ(object_zval);
call->called_scope = Z_CE_P(EX_VAR(opline->op1.var));
call->num_additional_args = 0;
call->is_ctor_call = 1;
if (EX(call) >= EX(call_slots)) {
call_slot *call = EX(call);
do {
- if (Z_TYPE(call->object) != IS_UNDEF) {
+ if (call->object) {
if (call->is_ctor_call) {
if (call->is_ctor_result_used) {
- Z_DELREF(call->object);
+ call->object->gc.refcount--;
}
- if (Z_REFCOUNT(call->object) == 1) {
- zend_object_store_ctor_failed(&call->object TSRMLS_CC);
+ if (call->object->gc.refcount == 1) {
+ zend_object_store_ctor_failed(call->object TSRMLS_CC);
}
}
- zval_ptr_dtor(&call->object);
+ OBJ_RELEASE(call->object);
}
call--;
} while (call >= EX(call_slots));
CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
}
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
STR_FREE(lcname);
call->fbc = Z_FUNC_P(func);
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
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, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
- if (Z_REFCOUNTED(call->object)) {
- Z_ADDREF(call->object);
+ if (call->object) {
+ call->object->gc.refcount++;
}
if (IS_CONST == IS_VAR && 0 && Z_REFCOUNT_P(function_name) == 1 &&
call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
}
if (Z_TYPE_P(obj) == IS_STRING) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC);
if (UNEXPECTED(call->called_scope == NULL)) {
CHECK_EXCEPTION();
}
} else {
call->called_scope = Z_OBJCE_P(obj);
- ZVAL_COPY_VALUE(&call->object, obj);
+ call->object = Z_OBJ_P(obj);
- call->fbc = Z_OBJ_HT_P(obj)->get_method(obj, Z_STR_P(method), NULL TSRMLS_CC);
+ call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(obj), Z_STRVAL_P(method));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method));
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
}
CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
}
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
}
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
zval_dtor(free_op2.var);
call->fbc = Z_FUNC_P(func);
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
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, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
- if (Z_REFCOUNTED(call->object)) {
- Z_ADDREF(call->object);
+ if (call->object) {
+ call->object->gc.refcount++;
}
if (IS_TMP_VAR == IS_VAR && 1 && Z_REFCOUNT_P(function_name) == 1 &&
call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
}
if (Z_TYPE_P(obj) == IS_STRING) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC);
if (UNEXPECTED(call->called_scope == NULL)) {
CHECK_EXCEPTION();
}
} else {
call->called_scope = Z_OBJCE_P(obj);
- ZVAL_COPY_VALUE(&call->object, obj);
+ call->object = Z_OBJ_P(obj);
- call->fbc = Z_OBJ_HT_P(obj)->get_method(obj, Z_STR_P(method), NULL TSRMLS_CC);
+ call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(obj), Z_STRVAL_P(method));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method));
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
}
CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
}
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
zval_ptr_dtor_nogc(free_op2.var);
call->fbc = Z_FUNC_P(func);
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
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, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
- if (Z_REFCOUNTED(call->object)) {
- Z_ADDREF(call->object);
+ if (call->object) {
+ call->object->gc.refcount++;
}
if (IS_VAR == IS_VAR && (free_op2.var != NULL) && Z_REFCOUNT_P(function_name) == 1 &&
call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
}
if (Z_TYPE_P(obj) == IS_STRING) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC);
if (UNEXPECTED(call->called_scope == NULL)) {
CHECK_EXCEPTION();
}
} else {
call->called_scope = Z_OBJCE_P(obj);
- ZVAL_COPY_VALUE(&call->object, obj);
+ call->object = Z_OBJ_P(obj);
- call->fbc = Z_OBJ_HT_P(obj)->get_method(obj, Z_STR_P(method), NULL TSRMLS_CC);
+ call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(obj), Z_STRVAL_P(method));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method));
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
}
CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
}
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
STR_FREE(lcname);
call->fbc = Z_FUNC_P(func);
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
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, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
- if (Z_REFCOUNTED(call->object)) {
- Z_ADDREF(call->object);
+ if (call->object) {
+ call->object->gc.refcount++;
}
if (IS_CV == IS_VAR && 0 && Z_REFCOUNT_P(function_name) == 1 &&
call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
}
if (Z_TYPE_P(obj) == IS_STRING) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC);
if (UNEXPECTED(call->called_scope == NULL)) {
CHECK_EXCEPTION();
}
} else {
call->called_scope = Z_OBJCE_P(obj);
- ZVAL_COPY_VALUE(&call->object, obj);
+ call->object = Z_OBJ_P(obj);
- call->fbc = Z_OBJ_HT_P(obj)->get_method(obj, Z_STR_P(method), NULL TSRMLS_CC);
+ call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(obj), Z_STRVAL_P(method));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method));
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
}
}
call->fbc = EX(function_state).function;
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
call->called_scope = NULL;
call->num_additional_args = 0;
call->is_ctor_call = 0;
}
EX(function_state).function = (zend_function *) new_op_array;
- ZVAL_UNDEF(&EX(object));
+ EX(object) = NULL;
if (!EG(active_symbol_table)) {
zend_rebuild_symbol_table(TSRMLS_C);
if (UNEXPECTED(ce->constructor == NULL)) {
zend_error_noreturn(E_ERROR, "Cannot call constructor");
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+ if (Z_OBJ(EG(This)) && Z_OBJCE(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->val);
}
call->fbc = ce->constructor;
}
if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- if (Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
!instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
/* We are calling method of the other (incompatible) class,
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
}
}
- ZVAL_COPY(&call->object, &EG(This));
+ call->object = Z_OBJ(EG(This));
+ if (call->object) {
+ call->object->gc.refcount++;
+ }
}
call->num_additional_args = 0;
if (UNEXPECTED(ce->constructor == NULL)) {
zend_error_noreturn(E_ERROR, "Cannot call constructor");
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+ if (Z_OBJ(EG(This)) && Z_OBJCE(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->val);
}
call->fbc = ce->constructor;
}
if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- if (Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
!instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
/* We are calling method of the other (incompatible) class,
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
}
}
- ZVAL_COPY(&call->object, &EG(This));
+ call->object = Z_OBJ(EG(This));
+ if (call->object) {
+ call->object->gc.refcount++;
+ }
}
call->num_additional_args = 0;
if (UNEXPECTED(ce->constructor == NULL)) {
zend_error_noreturn(E_ERROR, "Cannot call constructor");
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+ if (Z_OBJ(EG(This)) && Z_OBJCE(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->val);
}
call->fbc = ce->constructor;
}
if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- if (Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
!instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
/* We are calling method of the other (incompatible) class,
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
}
}
- ZVAL_COPY(&call->object, &EG(This));
+ call->object = Z_OBJ(EG(This));
+ if (call->object) {
+ call->object->gc.refcount++;
+ }
}
call->num_additional_args = 0;
if (UNEXPECTED(ce->constructor == NULL)) {
zend_error_noreturn(E_ERROR, "Cannot call constructor");
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+ if (Z_OBJ(EG(This)) && Z_OBJCE(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->val);
}
call->fbc = ce->constructor;
}
if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- if (Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
!instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
/* We are calling method of the other (incompatible) class,
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
}
}
- ZVAL_COPY(&call->object, &EG(This));
+ call->object = Z_OBJ(EG(This));
+ if (call->object) {
+ call->object->gc.refcount++;
+ }
}
call->num_additional_args = 0;
zend_error_noreturn(E_ERROR, "Base lambda function for closure not found");
}
- zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc), EG(scope), &EG(This) TSRMLS_CC);
+ zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc), EG(scope), Z_OBJ(EG(This)) ? &EG(This) : NULL TSRMLS_CC);
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
if (UNEXPECTED(ce->constructor == NULL)) {
zend_error_noreturn(E_ERROR, "Cannot call constructor");
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+ if (Z_OBJ(EG(This)) && Z_OBJCE(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->val);
}
call->fbc = ce->constructor;
}
if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- if (Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
!instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
/* We are calling method of the other (incompatible) class,
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
}
}
- ZVAL_COPY(&call->object, &EG(This));
+ call->object = Z_OBJ(EG(This));
+ if (call->object) {
+ call->object->gc.refcount++;
+ }
}
call->num_additional_args = 0;
}
EX(function_state).function = (zend_function *) new_op_array;
- ZVAL_UNDEF(&EX(object));
+ EX(object) = NULL;
if (!EG(active_symbol_table)) {
zend_rebuild_symbol_table(TSRMLS_C);
}
object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_CONST != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_CONST == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
}
object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_TMP_VAR != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_TMP_VAR == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
}
object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_VAR != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_VAR == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
}
object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_CV != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_CV == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
}
EX(function_state).function = (zend_function *) new_op_array;
- ZVAL_UNDEF(&EX(object));
+ EX(object) = NULL;
if (!EG(active_symbol_table)) {
zend_rebuild_symbol_table(TSRMLS_C);
}
object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_CONST != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_CONST == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
if (UNEXPECTED(ce->constructor == NULL)) {
zend_error_noreturn(E_ERROR, "Cannot call constructor");
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+ if (Z_OBJ(EG(This)) && Z_OBJCE(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->val);
}
call->fbc = ce->constructor;
}
if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- if (Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
!instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
/* We are calling method of the other (incompatible) class,
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
}
}
- ZVAL_COPY(&call->object, &EG(This));
+ call->object = Z_OBJ(EG(This));
+ if (call->object) {
+ call->object->gc.refcount++;
+ }
}
call->num_additional_args = 0;
}
object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_TMP_VAR != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_TMP_VAR == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
if (UNEXPECTED(ce->constructor == NULL)) {
zend_error_noreturn(E_ERROR, "Cannot call constructor");
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+ if (Z_OBJ(EG(This)) && Z_OBJCE(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->val);
}
call->fbc = ce->constructor;
}
if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- if (Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
!instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
/* We are calling method of the other (incompatible) class,
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
}
}
- ZVAL_COPY(&call->object, &EG(This));
+ call->object = Z_OBJ(EG(This));
+ if (call->object) {
+ call->object->gc.refcount++;
+ }
}
call->num_additional_args = 0;
}
object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_VAR != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_VAR == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
if (UNEXPECTED(ce->constructor == NULL)) {
zend_error_noreturn(E_ERROR, "Cannot call constructor");
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+ if (Z_OBJ(EG(This)) && Z_OBJCE(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->val);
}
call->fbc = ce->constructor;
}
if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- if (Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
!instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
/* We are calling method of the other (incompatible) class,
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
}
}
- ZVAL_COPY(&call->object, &EG(This));
+ call->object = Z_OBJ(EG(This));
+ if (call->object) {
+ call->object->gc.refcount++;
+ }
}
call->num_additional_args = 0;
if (UNEXPECTED(ce->constructor == NULL)) {
zend_error_noreturn(E_ERROR, "Cannot call constructor");
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+ if (Z_OBJ(EG(This)) && Z_OBJCE(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->val);
}
call->fbc = ce->constructor;
}
if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- if (Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
!instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
/* We are calling method of the other (incompatible) class,
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
}
}
- ZVAL_COPY(&call->object, &EG(This));
+ call->object = Z_OBJ(EG(This));
+ if (call->object) {
+ call->object->gc.refcount++;
+ }
}
call->num_additional_args = 0;
}
object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_CV != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_CV == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
if (UNEXPECTED(ce->constructor == NULL)) {
zend_error_noreturn(E_ERROR, "Cannot call constructor");
}
- if (Z_TYPE(EG(This)) != IS_UNDEF && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+ if (Z_OBJ(EG(This)) && Z_OBJCE(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->val);
}
call->fbc = ce->constructor;
}
if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- if (Z_TYPE(EG(This)) != IS_UNDEF &&
+ if (Z_OBJ(EG(This)) &&
Z_OBJ_HT(EG(This))->get_class_entry &&
!instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
/* We are calling method of the other (incompatible) class,
zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
}
}
- ZVAL_COPY(&call->object, &EG(This));
+ call->object = Z_OBJ(EG(This));
+ if (call->object) {
+ call->object->gc.refcount++;
+ }
}
call->num_additional_args = 0;
}
object = _get_obj_zval_ptr_unused(TSRMLS_C);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_CONST != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_CONST == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
}
object = _get_obj_zval_ptr_unused(TSRMLS_C);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_TMP_VAR != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_TMP_VAR == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
}
object = _get_obj_zval_ptr_unused(TSRMLS_C);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_VAR != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_VAR == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
}
object = _get_obj_zval_ptr_unused(TSRMLS_C);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_CV != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_CV == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
}
EX(function_state).function = (zend_function *) new_op_array;
- ZVAL_UNDEF(&EX(object));
+ EX(object) = NULL;
if (!EG(active_symbol_table)) {
zend_rebuild_symbol_table(TSRMLS_C);
}
object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_CONST != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_CONST == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
}
object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_TMP_VAR != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_TMP_VAR == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
}
object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_VAR != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_VAR == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
}
object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
- ZVAL_COPY_VALUE(&call->object, object);
+ call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
- if (EXPECTED(Z_TYPE(call->object) != IS_UNDEF) &&
- EXPECTED(Z_TYPE(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE(call->object);
+ if (EXPECTED(call->object != NULL)) {
+ call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
if (IS_CV != IS_CONST ||
(call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zend_object *object = Z_OBJ(call->object);
+ zend_object *object = call->object;
- if (UNEXPECTED(Z_OBJ_HT(call->object)->get_method == NULL)) {
+ if (UNEXPECTED(object->handlers->get_method == NULL)) {
zend_error_noreturn(E_ERROR, "Object does not support method calls");
}
/* First, locate the function. */
- call->fbc = Z_OBJ_HT(call->object)->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+ call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(&call->object), Z_STRVAL_P(function_name));
+ zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
}
if (IS_CV == IS_CONST &&
EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(Z_OBJ(call->object) == object)) {
+ EXPECTED(call->object == object)) {
CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
}
}
}
if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- ZVAL_UNDEF(&call->object);
+ call->object = NULL;
} else {
- Z_ADDREF(call->object); /* For $this pointer */
+ call->object->gc.refcount++; /* For $this pointer */
}
call->num_additional_args = 0;
tzobj->type = TIMELIB_ZONETYPE_ID;
tzobj->tzi.tz = tzi;
tzobj->initialized = 1;
- } else {
- ZVAL_NULL(getThis());
+//??? } else {
+//??? ZVAL_NULL(getThis());
}
}
zend_restore_error_handling(&error_handling TSRMLS_CC);
diobj = Z_PHPINTERVAL_P(getThis());
diobj->diff = reltime;
diobj->initialized = 1;
- } else {
- ZVAL_NULL(getThis());
+//??? } else {
+//??? ZVAL_NULL(getThis());
}
}
zend_restore_error_handling(&error_handling TSRMLS_CC);
fci.function_table = &ce->function_table;
ZVAL_UNDEF(&fci.function_name);
fci.symbol_table = NULL;
- fci.object_ptr = return_value;
+ fci.object = Z_OBJ_P(return_value);
fci.retval = &retval;
if (ctor_params && Z_TYPE_P(ctor_params) != IS_NULL) {
if (Z_TYPE_P(ctor_params) == IS_ARRAY) {
fcc.function_handler = ce->constructor;
fcc.calling_scope = EG(scope);
fcc.called_scope = Z_OBJCE_P(return_value);
- ZVAL_COPY_VALUE(&fcc.object, return_value);
+ fcc.object = Z_OBJ_P(return_value);
if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Could not execute %s::%s()", ce->name->val, ce->constructor->common.function_name->val);
/* Method macros */
#define METHOD_NOTSTATIC(ce) \
- if (!this_ptr || !instanceof_function(Z_OBJCE_P(this_ptr), ce TSRMLS_CC)) { \
+ if (!Z_OBJ(EG(This)) || !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) { \
php_error_docref(NULL TSRMLS_CC, E_ERROR, "%s() cannot be called statically", get_active_function_name(TSRMLS_C)); \
return; \
} \
/* see if this is a closure */
if (ce == zend_ce_closure && obj && (len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
&& memcmp(mptr->common.function_name->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
- && (closure = zend_get_closure_invoke_method(obj TSRMLS_CC)) != NULL)
+ && (closure = zend_get_closure_invoke_method(Z_OBJ_P(obj) TSRMLS_CC)) != NULL)
{
mptr = closure;
} else {
fci.function_table = NULL;
ZVAL_UNDEF(&fci.function_name);
fci.symbol_table = NULL;
- fci.object_ptr = &reflector;
+ fci.object = Z_OBJ(reflector);
fci.retval = &retval;
fci.param_count = ctor_argc;
fci.params = params;
fcc.function_handler = ce_ptr->constructor;
fcc.calling_scope = ce_ptr;
fcc.called_scope = Z_OBJCE(reflector);
- ZVAL_COPY_VALUE(&fcc.object, &reflector);
+ fcc.object = Z_OBJ(reflector);
result = zend_call_function(&fci, &fcc TSRMLS_CC);
ZVAL_STRINGL(&fci.function_name, "reflection::export", sizeof("reflection::export") - 1);
fci.function_table = &reflection_ptr->function_table;
- fci.object_ptr = NULL;
+ fci.object = NULL;
fci.retval = &retval;
fci.param_count = 2;
fci.params = params;
fci.function_table = NULL;
ZVAL_UNDEF(&fci.function_name);
fci.symbol_table = NULL;
- fci.object_ptr = NULL;
+ fci.object = NULL;
fci.retval = &retval;
fci.param_count = num_args;
fci.params = params;
fcc.function_handler = fptr;
fcc.calling_scope = EG(scope);
fcc.called_scope = NULL;
- ZVAL_UNDEF(&fcc.object);
+ fcc.object = NULL;
result = zend_call_function(&fci, &fcc TSRMLS_CC);
fci.function_table = NULL;
ZVAL_UNDEF(&fci.function_name);
fci.symbol_table = NULL;
- fci.object_ptr = NULL;
+ fci.object = NULL;
fci.retval = &retval;
fci.param_count = argc;
fci.params = params;
fcc.function_handler = fptr;
fcc.calling_scope = EG(scope);
fcc.called_scope = NULL;
- ZVAL_UNDEF(&fcc.object);
+ fcc.object = NULL;
result = zend_call_function(&fci, &fcc TSRMLS_CC);
if (ce == zend_ce_closure && Z_TYPE_P(classref) == IS_OBJECT
&& (lcname_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
&& memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
- && (fptr = zend_get_closure_invoke_method(classref TSRMLS_CC)) != NULL)
+ && (fptr = zend_get_closure_invoke_method(Z_OBJ_P(classref) TSRMLS_CC)) != NULL)
{
/* nothing to do. don't set is_closure since is the invoke handler,
- not the closure itself */
if (ce == zend_ce_closure && orig_obj && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
&& memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
- && (mptr = zend_get_closure_invoke_method(orig_obj TSRMLS_CC)) != NULL)
+ && (mptr = zend_get_closure_invoke_method(Z_OBJ_P(orig_obj) TSRMLS_CC)) != NULL)
{
/* do nothing, mptr already set */
} else if ((mptr = zend_hash_str_find_ptr(&ce->function_table, lcname, name_len)) == NULL) {
{
zval retval;
zval *params = NULL;
- zval object;
+ zend_object *object;
reflection_object *intern;
zend_function *mptr;
int result, num_args = 0;
* Else, we verify that the given object is an instance of the class.
*/
if (mptr->common.fn_flags & ZEND_ACC_STATIC) {
- ZVAL_UNDEF(&object);
+ object = NULL;
obj_ce = mptr->common.scope;
} else {
if (Z_TYPE(params[0]) != IS_OBJECT) {
/* Returns from this function */
}
- ZVAL_COPY_VALUE(&object, ¶ms[0]);
+ object = Z_OBJ(params[0]);
}
fci.size = sizeof(fci);
fci.function_table = NULL;
ZVAL_UNDEF(&fci.function_name);
fci.symbol_table = NULL;
- fci.object_ptr = &object;
+ fci.object = object;
fci.retval = &retval;
fci.param_count = num_args - 1;
fci.params = params + 1;
fcc.function_handler = mptr;
fcc.calling_scope = obj_ce;
fcc.called_scope = intern->ce;
- ZVAL_COPY_VALUE(&fcc.object, &object);
+ fcc.object = object;
result = zend_call_function(&fci, &fcc TSRMLS_CC);
fci.function_table = NULL;
ZVAL_UNDEF(&fci.function_name);
fci.symbol_table = NULL;
- fci.object_ptr = object;
+ fci.object = object ? Z_OBJ_P(object) : NULL;
fci.retval = &retval;
fci.param_count = argc;
fci.params = params;
fcc.function_handler = mptr;
fcc.calling_scope = obj_ce;
fcc.called_scope = intern->ce;
- if (object) {
- ZVAL_COPY_VALUE(&fcc.object, object);
- } else {
- ZVAL_UNDEF(&fcc.object);
- }
+ fcc.object = (object) ? Z_OBJ_P(object) : NULL;
/*
* Copy the zend_function when calling via handler (e.g. Closure::__invoke())
lc_name = zend_str_tolower_dup(name, name_len);
if (ce == zend_ce_closure && !ZVAL_IS_UNDEF(&intern->obj) && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
&& memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
- && (mptr = zend_get_closure_invoke_method(&intern->obj TSRMLS_CC)) != NULL)
+ && (mptr = zend_get_closure_invoke_method(Z_OBJ(intern->obj) TSRMLS_CC)) != NULL)
{
/* don't assign closure_object since we only reflect the invoke handler
method and not the closure definition itself */
efree(lc_name);
} else if (ce == zend_ce_closure && ZVAL_IS_UNDEF(&intern->obj) && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
&& memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
- && object_init_ex(&obj_tmp, ce) == SUCCESS && (mptr = zend_get_closure_invoke_method(&obj_tmp TSRMLS_CC)) != NULL) {
+ && object_init_ex(&obj_tmp, ce) == SUCCESS && (mptr = zend_get_closure_invoke_method(Z_OBJ(obj_tmp) TSRMLS_CC)) != NULL) {
/* don't assign closure_object since we only reflect the invoke handler
method and not the closure definition itself */
reflection_method_factory(ce, mptr, NULL, return_value TSRMLS_CC);
if (mptr->common.fn_flags & filter) {
if (ce == zend_ce_closure && obj && (len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
&& memcmp(mptr->common.function_name->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
- && (closure = zend_get_closure_invoke_method(obj TSRMLS_CC)) != NULL)
+ && (closure = zend_get_closure_invoke_method(Z_OBJ_P(obj) TSRMLS_CC)) != NULL)
{
mptr = closure;
}
array_init(return_value);
zend_hash_apply_with_arguments(&ce->function_table TSRMLS_CC, (apply_func_args_t) _addmethod_va, 4, &ce, return_value, filter, intern->obj);
if (Z_TYPE(intern->obj) != IS_UNDEF && instanceof_function(ce, zend_ce_closure TSRMLS_CC)) {
- zend_function *closure = zend_get_closure_invoke_method(&intern->obj TSRMLS_CC);
+ zend_function *closure = zend_get_closure_invoke_method(Z_OBJ(intern->obj) TSRMLS_CC);
if (closure) {
_addmethod(closure, ce, return_value, filter, &intern->obj TSRMLS_CC);
_free_function(closure TSRMLS_CC);
old_scope = EG(scope);
EG(scope) = ce;
- constructor = Z_OBJ_HT_P(return_value)->get_constructor(return_value TSRMLS_CC);
+ constructor = Z_OBJ_HT_P(return_value)->get_constructor(Z_OBJ_P(return_value) TSRMLS_CC);
EG(scope) = old_scope;
/* Run the constructor if there is one */
fci.function_table = EG(function_table);
ZVAL_UNDEF(&fci.function_name);
fci.symbol_table = NULL;
- fci.object_ptr = return_value;
+ fci.object = Z_OBJ_P(return_value);
fci.retval = &retval;
fci.param_count = num_args;
fci.params = params;
fcc.function_handler = constructor;
fcc.calling_scope = EG(scope);
fcc.called_scope = Z_OBJCE_P(return_value);
- ZVAL_COPY_VALUE(&fcc.object, return_value);
+ fcc.object = Z_OBJ_P(return_value);
if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
if (!ZVAL_IS_UNDEF(&retval)) {
old_scope = EG(scope);
EG(scope) = ce;
- constructor = Z_OBJ_HT_P(return_value)->get_constructor(return_value TSRMLS_CC);
+ constructor = Z_OBJ_HT_P(return_value)->get_constructor(Z_OBJ_P(return_value) TSRMLS_CC);
EG(scope) = old_scope;
/* Run the constructor if there is one */
fci.function_table = EG(function_table);
ZVAL_UNDEF(&fci.function_name);
fci.symbol_table = NULL;
- fci.object_ptr = return_value;
+ fci.object = Z_OBJ_P(return_value);
fci.retval = &retval;
fci.param_count = argc;
fci.params = params;
fcc.function_handler = constructor;
fcc.calling_scope = EG(scope);
fcc.called_scope = Z_OBJCE_P(return_value);
- ZVAL_COPY_VALUE(&fcc.object, return_value);
+ fcc.object = Z_OBJ_P(return_value);
if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
if (params) {
zend_bool prepend = 0;
zend_function *spl_func_ptr;
autoload_func_info alfi;
- zval *obj_ptr;
+ zend_object *obj_ptr;
zend_fcall_info_cache fcc;
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "|zbb", &zcallable, &do_throw, &prepend) == FAILURE) {
if (!zend_is_callable_ex(zcallable, NULL, IS_CALLABLE_STRICT, &func_name, &fcc, &error TSRMLS_CC)) {
alfi.ce = fcc.calling_scope;
alfi.func_ptr = fcc.function_handler;
- obj_ptr = &fcc.object;
+ obj_ptr = fcc.object;
if (Z_TYPE_P(zcallable) == IS_ARRAY) {
- if (Z_TYPE_P(obj_ptr) == IS_UNDEF && alfi.func_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
+ if (!obj_ptr && alfi.func_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
if (do_throw) {
zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Passed array specifies a non static method but no object (%s)", error);
}
STR_RELEASE(func_name);
RETURN_FALSE;
} else if (do_throw) {
- zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Passed array does not specify %s %smethod (%s)", alfi.func_ptr ? "a callable" : "an existing", Z_TYPE_P(obj_ptr) == IS_UNDEF ? "static " : "", error);
+ zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Passed array does not specify %s %smethod (%s)", alfi.func_ptr ? "a callable" : "an existing", !obj_ptr ? "static " : "", error);
}
if (error) {
efree(error);
}
alfi.ce = fcc.calling_scope;
alfi.func_ptr = fcc.function_handler;
- obj_ptr = &fcc.object;
+ obj_ptr = fcc.object;
if (error) {
efree(error);
}
goto skip;
}
- if (Z_TYPE_P(obj_ptr) == IS_OBJECT && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
+ if (obj_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
/* add object id to the hash to ensure uniqueness, for more reference look at bug #40091 */
lc_name = STR_REALLOC(lc_name, lc_name->len + sizeof(zend_uint), 0);
- memcpy(lc_name->val + lc_name->len - sizeof(zend_uint), &Z_OBJ_HANDLE_P(obj_ptr), sizeof(zend_uint));
+ memcpy(lc_name->val + lc_name->len - sizeof(zend_uint), &obj_ptr->handle, sizeof(zend_uint));
lc_name->val[lc_name->len] = '\0';
- ZVAL_COPY(&alfi.obj, obj_ptr);
+ ZVAL_OBJ(&alfi.obj, obj_ptr);
+ Z_ADDREF(alfi.obj);
} else {
ZVAL_UNDEF(&alfi.obj);
}
}
if (zend_hash_add_mem(SPL_G(autoload_functions), lc_name, &alfi, sizeof(autoload_func_info)) == NULL) {
- if (Z_TYPE_P(obj_ptr) == IS_OBJECT && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
+ if (obj_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
Z_DELREF(alfi.obj);
}
if (!ZVAL_IS_UNDEF(&alfi.closure)) {
zval *zcallable;
int success = FAILURE;
zend_function *spl_func_ptr;
- zval *obj_ptr;
+ zend_object *obj_ptr;
zend_fcall_info_cache fcc;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zcallable) == FAILURE) {
}
RETURN_FALSE;
}
- obj_ptr = &fcc.object;
+ obj_ptr = fcc.object;
if (error) {
efree(error);
}
} else {
/* remove specific */
success = zend_hash_del(SPL_G(autoload_functions), lc_name);
- if (success != SUCCESS && Z_TYPE_P(obj_ptr) == IS_OBJECT) {
+ if (success != SUCCESS && obj_ptr) {
lc_name = STR_REALLOC(lc_name, lc_name->len + sizeof(zend_uint), 0);
- memcpy(lc_name->val + lc_name->len - sizeof(zend_uint), &Z_OBJ_HANDLE_P(obj_ptr), sizeof(zend_uint));
+ memcpy(lc_name->val + lc_name->len - sizeof(zend_uint), &obj_ptr->handle, sizeof(zend_uint));
lc_name->val[lc_name->len] = '\0';
success = zend_hash_del(SPL_G(autoload_functions), lc_name);
}
}
/* }}} */
-static HashTable *spl_filesystem_object_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* {{{ */
+static HashTable *spl_filesystem_object_get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
{
- spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(obj);
+ spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(object);
zval tmp;
HashTable *rv;
zend_string *pnstr;
}
/* }}} */
-zend_function *spl_filesystem_object_get_method_check(zval *object_ptr, zend_string *method, const struct _zend_literal *key TSRMLS_DC) /* {{{ */
+zend_function *spl_filesystem_object_get_method_check(zend_object **object, zend_string *method, const struct _zend_literal *key TSRMLS_DC) /* {{{ */
{
- spl_filesystem_object *fsobj = Z_SPLFILESYSTEM_P(object_ptr);
+ spl_filesystem_object *fsobj = spl_filesystem_from_obj(*object);
if (fsobj->u.dir.entry.d_name[0] == '\0' && fsobj->orig_path == NULL) {
zend_function *func;
zend_string *tmp = STR_INIT("_bad_state_ex", sizeof("_bad_state_ex") - 1, 0);
- func = zend_get_std_object_handlers()->get_method(object_ptr, tmp, NULL TSRMLS_CC);
+ func = zend_get_std_object_handlers()->get_method(object, tmp, NULL TSRMLS_CC);
STR_RELEASE(tmp);
return func;
}
- return zend_get_std_object_handlers()->get_method(object_ptr, method, key TSRMLS_CC);
+ return zend_get_std_object_handlers()->get_method(object, method, key TSRMLS_CC);
}
/* }}} */
if (intern->u.dir.index > pos) {
/* we first rewind */
- zend_call_method_with_0_params(this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_rewind, "rewind", NULL);
+ zend_call_method_with_0_params(&EG(This), Z_OBJCE(EG(This)), &intern->u.dir.func_rewind, "rewind", NULL);
}
while (intern->u.dir.index < pos) {
int valid = 0;
- zend_call_method_with_0_params(this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_valid, "valid", &retval);
+ zend_call_method_with_0_params(&EG(This), Z_OBJCE(EG(This)), &intern->u.dir.func_valid, "valid", &retval);
if (!ZVAL_IS_UNDEF(&retval)) {
valid = zend_is_true(&retval TSRMLS_CC);
zval_ptr_dtor(&retval);
if (!valid) {
break;
}
- zend_call_method_with_0_params(this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_next, "next", NULL);
+ zend_call_method_with_0_params(&EG(This), Z_OBJCE(EG(This)), &intern->u.dir.func_next, "next", NULL);
}
} /* }}} */
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
- fci.object_ptr = NULL;
+ fci.object = NULL;
fci.retval = &retval;
fci.param_count = num_args;
fci.params = params;
fcic.function_handler = func_ptr;
fcic.calling_scope = NULL;
fcic.called_scope = NULL;
- ZVAL_UNDEF(&fcic.object);
+ fcic.object = NULL;
result = zend_call_function(&fci, &fcic TSRMLS_CC);
}
} /* }}} */
-static union _zend_function *spl_recursive_it_get_method(zval *object_ptr, zend_string *method, const zend_literal *key TSRMLS_DC)
+static union _zend_function *spl_recursive_it_get_method(zend_object **zobject, zend_string *method, const zend_literal *key TSRMLS_DC)
{
union _zend_function *function_handler;
- spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(object_ptr);
+ spl_recursive_it_object *object = spl_recursive_it_from_obj(*zobject);
long level = object->level;
zval *zobj;
if (!object->iterators) {
- php_error_docref(NULL TSRMLS_CC, E_ERROR, "The %s instance wasn't initialized properly", Z_OBJCE_P(object_ptr)->name->val);
+ php_error_docref(NULL TSRMLS_CC, E_ERROR, "The %s instance wasn't initialized properly", zend_get_class_entry(*zobject TSRMLS_CC)->name->val);
}
zobj = &object->iterators[level].zobject;
- function_handler = std_object_handlers.get_method(object_ptr, method, key TSRMLS_CC);
+ function_handler = std_object_handlers.get_method(zobject, method, key TSRMLS_CC);
if (!function_handler) {
if ((function_handler = zend_hash_find_ptr(&Z_OBJCE_P(zobj)->function_table, method)) == NULL) {
if (Z_OBJ_HT_P(zobj)->get_method) {
- ZVAL_COPY_VALUE(object_ptr, zobj);
- function_handler = Z_OBJ_HT_P(object_ptr)->get_method(object_ptr, method, key TSRMLS_CC);
+ *zobject = Z_OBJ_P(zobj);
+ function_handler = (*zobject)->handlers->get_method(zobject, method, key TSRMLS_CC);
}
}
}
}
#endif
-static union _zend_function *spl_dual_it_get_method(zval *object_ptr, zend_string *method, const zend_literal *key TSRMLS_DC)
+static union _zend_function *spl_dual_it_get_method(zend_object **object, zend_string *method, const zend_literal *key TSRMLS_DC)
{
union _zend_function *function_handler;
spl_dual_it_object *intern;
- intern = Z_SPLDUAL_IT_P(object_ptr);
+ intern = spl_dual_it_from_obj(*object);
- function_handler = std_object_handlers.get_method(object_ptr, method, key TSRMLS_CC);
+ function_handler = std_object_handlers.get_method(object, method, key TSRMLS_CC);
if (!function_handler && intern->inner.ce) {
if ((function_handler = zend_hash_find_ptr(&intern->inner.ce->function_table, method)) == NULL) {
if (Z_OBJ_HT(intern->inner.zobject)->get_method) {
- ZVAL_COPY_VALUE(object_ptr, &intern->inner.zobject);
- function_handler = Z_OBJ_HT_P(object_ptr)->get_method(object_ptr, method, key TSRMLS_CC);
+ *object = Z_OBJ(intern->inner.zobject);
+ function_handler = (*object)->handlers->get_method(object, method, key TSRMLS_CC);
}
} else {
- ZVAL_COPY_VALUE(object_ptr, &intern->inner.zobject);
+ *object = Z_OBJ(intern->inner.zobject);
}
}
return function_handler;
case DIT_CallbackFilterIterator:
case DIT_RecursiveCallbackFilterIterator: {
_spl_cbfilter_it_intern *cfi = emalloc(sizeof(*cfi));
- cfi->fci.object_ptr = NULL;
+ cfi->fci.object = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Of", &zobject, ce_inner, &cfi->fci, &cfi->fcc) == FAILURE) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
efree(cfi);
if (Z_REFCOUNTED_P(&cfi->fci.function_name)) {
Z_ADDREF(cfi->fci.function_name);
}
- if (Z_TYPE(cfi->fcc.object) == IS_OBJECT) {
- ZVAL_COPY(&cfi->object, &cfi->fcc.object);
- }
+ cfi->object = cfi->fcc.object;
+ if (cfi->object) cfi->object->gc.refcount++;
intern->u.cbfilter = cfi;
break;
}
_spl_cbfilter_it_intern *cbfilter = object->u.cbfilter;
object->u.cbfilter = NULL;
zval_ptr_dtor(&cbfilter->fci.function_name);
- if (cbfilter->fci.object_ptr) {
- zval_ptr_dtor(cbfilter->fci.object_ptr);
+ if (cbfilter->fci.object) {
+ OBJ_RELEASE(cbfilter->fci.object);
}
efree(cbfilter);
}
typedef struct _spl_cbfilter_it_intern {
zend_fcall_info fci;
zend_fcall_info_cache fcc;
- zval object;
+ zend_object *object;
} _spl_cbfilter_it_intern;
typedef struct _spl_dual_it_object {
zend_hash_internal_pointer_end(array);
- if (return_value_used) {
+ if (USED_RET()) {
if ((entry = zend_hash_get_current_data(array)) == NULL) {
RETURN_FALSE;
}
zend_hash_move_backwards(array);
- if (return_value_used) {
+ if (USED_RET()) {
if ((entry = zend_hash_get_current_data(array)) == NULL) {
RETURN_FALSE;
}
zend_hash_move_forward(array);
- if (return_value_used) {
+ if (USED_RET()) {
if ((entry = zend_hash_get_current_data(array)) == NULL) {
RETURN_FALSE;
}
zend_hash_internal_pointer_reset(array);
- if (return_value_used) {
+ if (USED_RET()) {
if ((entry = zend_hash_get_current_data(array)) == NULL) {
RETURN_FALSE;
}
/* Don't create the array of removed elements if it's not going
* to be used; e.g. only removing and/or replacing elements */
- if (return_value_used) {
+ if (USED_RET()) {
int size = length;
/* Clamp the offset.. */
} \
if (ZEND_NUM_ARGS() == 0) { \
myself = getThis(); \
- if (!ZVAL_IS_UNDEF(myself)) { \
+ if (myself) { \
if ((tmp = zend_hash_str_find(Z_OBJPROP_P(myself), "handle", sizeof("handle")-1)) == NULL) { \
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find my handle property"); \
RETURN_FALSE; \
}
/* }}} */
-static union _zend_function *incomplete_class_get_method(zval *object, zend_string *method, const zend_literal *key TSRMLS_DC) /* {{{ */
+static union _zend_function *incomplete_class_get_method(zend_object **object, zend_string *method, const zend_literal *key TSRMLS_DC) /* {{{ */
{
- incomplete_class_message(object, E_ERROR TSRMLS_CC);
+ zval zobject;
+
+ ZVAL_OBJ(&zobject, *object);
+ incomplete_class_message(&zobject, E_ERROR TSRMLS_CC);
return NULL;
}
/* }}} */
} \
incomplete_class = 1; \
} else { \
- class_name = zend_get_object_classname(struc TSRMLS_CC); \
+ class_name = zend_get_object_classname(Z_OBJ_P(struc) TSRMLS_CC); \
}
#define PHP_CLEANUP_CLASS_ATTRIBUTES() \
}
if (Z_OBJ_HANDLER_P(struc, get_class_name)) {
- class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(struc, 0 TSRMLS_CC);
+ class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc), 0 TSRMLS_CC);
php_printf("%sobject(%s)#%d (%d) {\n", COMMON, class_name->val, Z_OBJ_HANDLE_P(struc), myht ? zend_obj_num_elements(myht) : 0);
STR_RELEASE(class_name);
} else {
PUTS("*RECURSION*\n");
return;
}
- class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(struc, 0 TSRMLS_CC);
+ class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc), 0 TSRMLS_CC);
php_printf("%sobject(%s)#%d (%d) refcount(%u){\n", COMMON, class_name->val, Z_OBJ_HANDLE_P(struc), myht ? zend_obj_num_elements(myht) : 0, Z_REFCOUNT_P(struc));
STR_RELEASE(class_name);
zval_element_dump_func = zval_object_property_dump;
smart_str_appendc(buf, '\n');
buffer_append_spaces(buf, level - 1);
}
- class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(struc, 0 TSRMLS_CC);
+ class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc), 0 TSRMLS_CC);
smart_str_appendl(buf, class_name->val, class_name->len);
smart_str_appendl(buf, "::__set_state(array(\n", 21);
php_var_serialize_intern(buf, d, var_hash TSRMLS_CC);
} else {
zend_class_entry *ce;
- ce = zend_get_class_entry(struc TSRMLS_CC);
+ ce = zend_get_class_entry(Z_OBJ_P(struc) TSRMLS_CC);
if (ce) {
zend_string *prot_name, *priv_name;
fci.function_table = &uwrap->ce->function_table;
ZVAL_UNDEF(&fci.function_name);
fci.symbol_table = NULL;
- fci.object_ptr = object;
+ fci.object = Z_OBJ_P(object);
fci.retval = &retval;
fci.param_count = 0;
fci.params = NULL;
fcc.function_handler = uwrap->ce->constructor;
fcc.calling_scope = EG(scope);
fcc.called_scope = Z_OBJCE_P(object);
- ZVAL_COPY_VALUE(&fcc.object, object);
+ fcc.object = Z_OBJ_P(object);
if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not execute %s::%s()", uwrap->ce->name->val, uwrap->ce->constructor->common.function_name->val);
switch (value) {
case PHP_STREAM_TRUNCATE_SUPPORTED:
if (zend_is_callable_ex(&func_name,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ ZVAL_IS_UNDEF(&us->object)? NULL : Z_OBJ(us->object),
IS_CALLABLE_CHECK_SILENT, NULL, NULL, NULL TSRMLS_CC))
ret = PHP_STREAM_OPTION_RETURN_OK;
else
EG(opline_ptr) = &PHPDBG_EX(opline);
EG(active_op_array) = PHPDBG_EX(op_array);
EG(active_symbol_table) = PHPDBG_EX(symbol_table);
- ZVAL_COPY_VALUE(&EG(This), &PHPDBG_EX(current_this));
+ Z_OBJ(EG(This)) = PHPDBG_EX(current_this);
EG(scope) = PHPDBG_EX(current_scope);
EG(called_scope) = PHPDBG_EX(current_called_scope);
} /* }}} */
EG(opline_ptr) = &PHPDBG_EX(opline);
EG(active_op_array) = PHPDBG_EX(op_array);
EG(active_symbol_table) = PHPDBG_EX(symbol_table);
- ZVAL_COPY_VALUE(&EG(This), &PHPDBG_EX(current_this));
+ Z_OBJ(EG(This)) = PHPDBG_EX(current_this);
EG(scope) = PHPDBG_EX(current_scope);
EG(called_scope) = PHPDBG_EX(current_called_scope);
}
if ((class = zend_hash_str_find(Z_ARRVAL_P(tmp), "object", sizeof("object") - 1)) == NULL) {
class = zend_hash_str_find(Z_ARRVAL_P(tmp), "class", sizeof("class") - 1);
} else {
- class_name = zend_get_object_classname(class TSRMLS_CC);
+ class_name = zend_get_object_classname(Z_OBJ_P(class) TSRMLS_CC);
}
if (class) {
fci.function_table = &PHPDBG_G(registered);
ZVAL_STRINGL(&fci.function_name, function->string, function->length);
fci.symbol_table = EG(active_symbol_table);
- fci.object_ptr = NULL;
+ fci.object = NULL;
fci.retval = &fretval;
fci.no_separation = 1;
fci.function_table = &Z_OBJCE(exception)->function_table;
ZVAL_STRINGL(&fci.function_name, "__tostring", sizeof("__tostring") - 1);
fci.symbol_table = NULL;
- fci.object_ptr = &exception;
+ fci.object = EG(exception);
fci.retval = &trace;
fci.param_count = 0;
fci.params = NULL;
projects / php / commitdiff