diff --git a/Zend/Optimizer/ssa_integrity.c b/Zend/Optimizer/ssa_integrity.c index b525f8d5ee226..121583088c4c1 100644 --- a/Zend/Optimizer/ssa_integrity.c +++ b/Zend/Optimizer/ssa_integrity.c @@ -97,7 +97,7 @@ static inline bool is_defined(const zend_ssa *ssa, const zend_op_array *op_array #define FAIL(...) do { \ if (status == SUCCESS) { \ fprintf(stderr, "\nIn function %s::%s (%s):\n", \ - op_array->scope ? ZSTR_VAL(op_array->scope->name) : "", \ + op_array->scope ? ZSTR_VAL(op_array->scope->namespaced_name.name) : "", \ op_array->function_name ? ZSTR_VAL(op_array->function_name) : "{main}", extra); \ } \ fprintf(stderr, __VA_ARGS__); \ diff --git a/Zend/Optimizer/zend_dump.c b/Zend/Optimizer/zend_dump.c index 4e46b38a8eb5e..a4e43125898b6 100644 --- a/Zend/Optimizer/zend_dump.c +++ b/Zend/Optimizer/zend_dump.c @@ -221,9 +221,9 @@ static void zend_dump_type_info(uint32_t info, zend_class_entry *ce, int is_inst fprintf(stderr, "class"); if (ce) { if (is_instanceof) { - fprintf(stderr, " (instanceof %s)", ce->name->val); + fprintf(stderr, " (instanceof %s)", (ce->namespaced_name.name)->val); } else { - fprintf(stderr, " (%s)", ce->name->val); + fprintf(stderr, " (%s)", (ce->namespaced_name.name)->val); } } } else if ((info & MAY_BE_ANY) == MAY_BE_ANY) { @@ -356,9 +356,9 @@ static void zend_dump_type_info(uint32_t info, zend_class_entry *ce, int is_inst fprintf(stderr, "object"); if (ce) { if (is_instanceof) { - fprintf(stderr, " (instanceof %s)", ce->name->val); + fprintf(stderr, " (instanceof %s)", (ce->namespaced_name.name)->val); } else { - fprintf(stderr, " (%s)", ce->name->val); + fprintf(stderr, " (%s)", (ce->namespaced_name.name)->val); } } } @@ -931,8 +931,8 @@ static void zend_dump_block_header(const zend_cfg *cfg, const zend_op_array *op_ void zend_dump_op_array_name(const zend_op_array *op_array) { if (op_array->function_name) { - if (op_array->scope && op_array->scope->name) { - fprintf(stderr, "%s::%s", op_array->scope->name->val, op_array->function_name->val); + if (op_array->scope && op_array->scope->namespaced_name.name) { + fprintf(stderr, "%s::%s", (op_array->scope->namespaced_name.name)->val, op_array->function_name->val); } else { fprintf(stderr, "%s", op_array->function_name->val); } diff --git a/Zend/Optimizer/zend_optimizer.c b/Zend/Optimizer/zend_optimizer.c index 9f2e3115d3666..cd4327b9ab806 100644 --- a/Zend/Optimizer/zend_optimizer.c +++ b/Zend/Optimizer/zend_optimizer.c @@ -842,7 +842,7 @@ zend_class_entry *zend_optimizer_get_class_entry( return Z_PTR_P(ce_zv); } - if (op_array && op_array->scope && zend_string_equals_ci(op_array->scope->name, lcname)) { + if (op_array && op_array->scope && zend_string_equals_ci(op_array->scope->namespaced_name.name, lcname)) { return op_array->scope; } diff --git a/Zend/tests/errmsg/errmsg_027.phpt b/Zend/tests/errmsg/errmsg_027.phpt index 3d96ec27b4d64..a30e1269453f9 100644 --- a/Zend/tests/errmsg/errmsg_027.phpt +++ b/Zend/tests/errmsg/errmsg_027.phpt @@ -13,4 +13,4 @@ class test { echo "Done\n"; ?> --EXPECTF-- -Fatal error: Class declarations may not be nested in %s on line %d +Fatal error: Class declarations may not be declared inside functions in %s on line %d diff --git a/Zend/zend.h b/Zend/zend.h index 0cf1faeb653fe..9c89ea69353e2 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -82,6 +82,21 @@ struct _zend_unserialize_data; typedef struct _zend_serialize_data zend_serialize_data; typedef struct _zend_unserialize_data zend_unserialize_data; +typedef enum _zend_name_resolution_kind { + ZEND_NAME_LEXICAL_SCOPE, + ZEND_NAME_NAMESPACE, +} zend_name_resolution_kind; + +typedef struct _zend_namespaced_name { + zend_string *name; + zend_string *resolved_name; + zend_name_resolution_kind kind; + union { + zend_class_entry *lexical_scope; + zend_string *namespace_name; + }; +} zend_namespaced_name; + typedef struct _zend_class_name { zend_string *name; zend_string *lc_name; @@ -146,11 +161,11 @@ struct _zend_inheritance_cache_entry { struct _zend_class_entry { char type; - zend_string *name; + zend_namespaced_name namespaced_name; /* class_entry or string depending on ZEND_ACC_LINKED */ union { zend_class_entry *parent; - zend_string *parent_name; + zend_namespaced_name *parent_name; }; int refcount; uint32_t ce_flags; @@ -164,6 +179,10 @@ struct _zend_class_entry { HashTable properties_info; HashTable constants_table; + zend_class_entry *required_scope; + zend_class_entry *lexical_scope; + char required_scope_absolute; + ZEND_MAP_PTR_DEF(zend_class_mutable_data*, mutable_data); zend_inheritance_cache_entry *inheritance_cache; @@ -210,10 +229,10 @@ struct _zend_class_entry { /* class_entry or string(s) depending on ZEND_ACC_LINKED */ union { zend_class_entry **interfaces; - zend_class_name *interface_names; + zend_namespaced_name *interface_names; }; - zend_class_name *trait_names; + zend_namespaced_name *trait_names; zend_trait_alias **trait_aliases; zend_trait_precedence **trait_precedences; HashTable *attributes; diff --git a/Zend/zend_API.c b/Zend/zend_API.c index 7023bf1a36b4b..0bec993a84e0f 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -154,7 +154,7 @@ ZEND_API const char *zend_zval_value_name(const zval *arg) } if (Z_TYPE_P(arg) == IS_OBJECT) { - return ZSTR_VAL(Z_OBJCE_P(arg)->name); + return ZSTR_VAL(Z_OBJCE_P(arg)->namespaced_name.name); } else if (Z_TYPE_P(arg) == IS_FALSE) { return "false"; } else if (Z_TYPE_P(arg) == IS_TRUE) { @@ -173,7 +173,7 @@ ZEND_API const char *zend_zval_type_name(const zval *arg) } if (Z_TYPE_P(arg) == IS_OBJECT) { - return ZSTR_VAL(Z_OBJCE_P(arg)->name); + return ZSTR_VAL(Z_OBJCE_P(arg)->namespaced_name.name); } return zend_get_type_by_const(Z_TYPE_P(arg)); @@ -462,7 +462,7 @@ ZEND_API ZEND_COLD void zend_class_redeclaration_error_ex(int type, zend_string ZEND_API ZEND_COLD void zend_class_redeclaration_error(int type, zend_class_entry *old_ce) { - zend_class_redeclaration_error_ex(type, old_ce->name, old_ce); + zend_class_redeclaration_error_ex(type, old_ce->namespaced_name.name, old_ce); } ZEND_API bool ZEND_FASTCALL zend_parse_arg_class(zval *arg, zend_class_entry **pce, uint32_t num, bool check_null) /* {{{ */ @@ -481,7 +481,7 @@ ZEND_API bool ZEND_FASTCALL zend_parse_arg_class(zval *arg, zend_class_entry **p *pce = zend_lookup_class(Z_STR_P(arg)); if (ce_base) { if ((!*pce || !instanceof_function(*pce, ce_base))) { - zend_argument_type_error(num, "must be a class name derived from %s, %s given", ZSTR_VAL(ce_base->name), Z_STRVAL_P(arg)); + zend_argument_type_error(num, "must be a class name derived from %s, %s given", ZSTR_VAL(ce_base->namespaced_name.name), Z_STRVAL_P(arg)); *pce = NULL; return 0; } @@ -984,10 +984,10 @@ static const char *zend_parse_arg_impl(zval *arg, va_list *va, const char **spec if (!zend_parse_arg_object(arg, p, ce, check_null)) { if (ce) { if (check_null) { - zend_spprintf(error, 0, "must be of type ?%s, %s given", ZSTR_VAL(ce->name), zend_zval_value_name(arg)); + zend_spprintf(error, 0, "must be of type ?%s, %s given", ZSTR_VAL(ce->namespaced_name.name), zend_zval_value_name(arg)); return ""; } else { - return ZSTR_VAL(ce->name); + return ZSTR_VAL(ce->namespaced_name.name); } } else { return check_null ? "?object" : "object"; @@ -1018,7 +1018,7 @@ static const char *zend_parse_arg_impl(zval *arg, va_list *va, const char **spec if (ce_base) { if ((!*pce || !instanceof_function(*pce, ce_base))) { zend_spprintf(error, 0, "must be a class name derived from %s%s, %s given", - ZSTR_VAL(ce_base->name), check_null ? " or null" : "", Z_STRVAL_P(arg)); + ZSTR_VAL(ce_base->namespaced_name.name), check_null ? " or null" : "", Z_STRVAL_P(arg)); *pce = NULL; return ""; } @@ -1135,7 +1135,7 @@ ZEND_API zend_result zend_parse_parameter(int flags, uint32_t arg_num, zval *arg static ZEND_COLD void zend_parse_parameters_debug_error(const char *msg) { zend_function *active_function = EG(current_execute_data)->func; const char *class_name = active_function->common.scope - ? ZSTR_VAL(active_function->common.scope->name) : ""; + ? ZSTR_VAL(active_function->common.scope->namespaced_name.name) : ""; zend_error_noreturn(E_CORE_ERROR, "%s%s%s(): %s", class_name, class_name[0] ? "::" : "", ZSTR_VAL(active_function->common.function_name), msg); @@ -1341,7 +1341,7 @@ ZEND_API zend_result zend_parse_method_parameters(uint32_t num_args, zval *this_ if (ce && !instanceof_function(Z_OBJCE_P(this_ptr), ce)) { zend_error_noreturn(E_CORE_ERROR, "%s::%s() must be derived from %s::%s()", - ZSTR_VAL(Z_OBJCE_P(this_ptr)->name), get_active_function_name(), ZSTR_VAL(ce->name), get_active_function_name()); + ZSTR_VAL(Z_OBJCE_P(this_ptr)->namespaced_name.name), get_active_function_name(), ZSTR_VAL(ce->namespaced_name.name), get_active_function_name()); } retval = zend_parse_va_args(num_args, p, &va, flags); @@ -1374,7 +1374,7 @@ ZEND_API zend_result zend_parse_method_parameters_ex(int flags, uint32_t num_arg if (ce && !instanceof_function(Z_OBJCE_P(this_ptr), ce)) { if (!(flags & ZEND_PARSE_PARAMS_QUIET)) { zend_error_noreturn(E_CORE_ERROR, "%s::%s() must be derived from %s::%s()", - ZSTR_VAL(ce->name), get_active_function_name(), ZSTR_VAL(Z_OBJCE_P(this_ptr)->name), get_active_function_name()); + ZSTR_VAL(ce->namespaced_name.name), get_active_function_name(), ZSTR_VAL(Z_OBJCE_P(this_ptr)->namespaced_name.name), get_active_function_name()); } va_end(va); return FAILURE; @@ -1768,11 +1768,11 @@ ZEND_API void object_properties_load(zend_object *object, HashTable *properties) } else { if (UNEXPECTED(object->ce->ce_flags & ZEND_ACC_NO_DYNAMIC_PROPERTIES)) { zend_throw_error(NULL, "Cannot create dynamic property %s::$%s", - ZSTR_VAL(object->ce->name), property_info != ZEND_WRONG_PROPERTY_INFO ? zend_get_unmangled_property_name(key): ""); + ZSTR_VAL(object->ce->namespaced_name.name), property_info != ZEND_WRONG_PROPERTY_INFO ? zend_get_unmangled_property_name(key): ""); return; } else if (!(object->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { zend_error(E_DEPRECATED, "Creation of dynamic property %s::$%s is deprecated", - ZSTR_VAL(object->ce->name), property_info != ZEND_WRONG_PROPERTY_INFO ? zend_get_unmangled_property_name(key): ""); + ZSTR_VAL(object->ce->namespaced_name.name), property_info != ZEND_WRONG_PROPERTY_INFO ? zend_get_unmangled_property_name(key): ""); } prop = zend_hash_update(zend_std_get_properties_ex(object), key, prop); @@ -1780,11 +1780,11 @@ ZEND_API void object_properties_load(zend_object *object, HashTable *properties) } } else { if (UNEXPECTED(object->ce->ce_flags & ZEND_ACC_NO_DYNAMIC_PROPERTIES)) { - zend_throw_error(NULL, "Cannot create dynamic property %s::$" ZEND_LONG_FMT, ZSTR_VAL(object->ce->name), h); + zend_throw_error(NULL, "Cannot create dynamic property %s::$" ZEND_LONG_FMT, ZSTR_VAL(object->ce->namespaced_name.name), h); return; } else if (!(object->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { zend_error(E_DEPRECATED, "Creation of dynamic property %s::$" ZEND_LONG_FMT " is deprecated", - ZSTR_VAL(object->ce->name), h); + ZSTR_VAL(object->ce->namespaced_name.name), h); } prop = zend_hash_index_update(zend_std_get_properties_ex(object), h, prop); @@ -1802,20 +1802,35 @@ static zend_always_inline zend_result _object_and_properties_init(zval *arg, zen { if (UNEXPECTED(class_type->ce_flags & ZEND_ACC_UNINSTANTIABLE)) { if (class_type->ce_flags & ZEND_ACC_INTERFACE) { - zend_throw_error(NULL, "Cannot instantiate interface %s", ZSTR_VAL(class_type->name)); + zend_throw_error(NULL, "Cannot instantiate interface %s", ZSTR_VAL(class_type->namespaced_name.name)); } else if (class_type->ce_flags & ZEND_ACC_TRAIT) { - zend_throw_error(NULL, "Cannot instantiate trait %s", ZSTR_VAL(class_type->name)); + zend_throw_error(NULL, "Cannot instantiate trait %s", ZSTR_VAL(class_type->namespaced_name.name)); } else if (class_type->ce_flags & ZEND_ACC_ENUM) { - zend_throw_error(NULL, "Cannot instantiate enum %s", ZSTR_VAL(class_type->name)); + zend_throw_error(NULL, "Cannot instantiate enum %s", ZSTR_VAL(class_type->namespaced_name.name)); } else { ZEND_ASSERT(class_type->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)); - zend_throw_error(NULL, "Cannot instantiate abstract class %s", ZSTR_VAL(class_type->name)); + zend_throw_error(NULL, "Cannot instantiate abstract class %s", ZSTR_VAL(class_type->namespaced_name.name)); } ZVAL_NULL(arg); Z_OBJ_P(arg) = NULL; return FAILURE; } + if (class_type->required_scope) { + const zend_class_entry *scope = zend_get_executed_scope(); + if (scope == NULL) { + zend_error(E_ERROR, "Cannot instantiate \"%s\" from the global scope", ZSTR_VAL(class_type->namespaced_name.name)); + } + + if (class_type->required_scope_absolute) { + if (scope != class_type->required_scope && scope->lexical_scope != class_type->required_scope) { + zend_error(E_ERROR, "Cannot instantiate private \"%s\" from \"%s\"", ZSTR_VAL(class_type->namespaced_name.name), ZSTR_VAL(scope->namespaced_name.name)); + } + } else if (!instanceof_function(scope, class_type->required_scope) && !instanceof_function(scope->lexical_scope, class_type->required_scope)) { + zend_error(E_ERROR, "Cannot instantiate protected \"%s\" from \"%s\"", ZSTR_VAL(class_type->namespaced_name.name), ZSTR_VAL(scope->namespaced_name.name)); + } + } + if (UNEXPECTED(!(class_type->ce_flags & ZEND_ACC_CONSTANTS_UPDATED))) { if (UNEXPECTED(zend_update_class_constants(class_type) != SUCCESS)) { ZVAL_NULL(arg); @@ -2664,20 +2679,20 @@ static void zend_check_magic_method_args( if (fptr->common.num_args != num_args) { if (num_args == 0) { zend_error(error_type, "Method %s::%s() cannot take arguments", - ZSTR_VAL(ce->name), ZSTR_VAL(fptr->common.function_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(fptr->common.function_name)); } else if (num_args == 1) { zend_error(error_type, "Method %s::%s() must take exactly 1 argument", - ZSTR_VAL(ce->name), ZSTR_VAL(fptr->common.function_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(fptr->common.function_name)); } else { zend_error(error_type, "Method %s::%s() must take exactly %" PRIu32 " arguments", - ZSTR_VAL(ce->name), ZSTR_VAL(fptr->common.function_name), num_args); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(fptr->common.function_name), num_args); } return; } for (uint32_t i = 0; i < num_args; i++) { if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(fptr, i + 1)) { zend_error(error_type, "Method %s::%s() cannot take arguments by reference", - ZSTR_VAL(ce->name), ZSTR_VAL(fptr->common.function_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(fptr->common.function_name)); return; } } @@ -2690,7 +2705,7 @@ static void zend_check_magic_method_arg_type(uint32_t arg_num, const zend_class_ && !(ZEND_TYPE_FULL_MASK(fptr->common.arg_info[arg_num].type) & arg_type) ) { zend_error(error_type, "%s::%s(): Parameter #%d ($%s) must be of type %s when declared", - ZSTR_VAL(ce->name), ZSTR_VAL(fptr->common.function_name), + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(fptr->common.function_name), arg_num + 1, ZSTR_VAL(fptr->common.arg_info[arg_num].name), ZSTR_VAL(zend_type_to_string((zend_type) ZEND_TYPE_INIT_MASK(arg_type)))); } @@ -2717,7 +2732,7 @@ static void zend_check_magic_method_return_type(const zend_class_entry *ce, cons if (extra_types || (is_complex_type && return_type != MAY_BE_OBJECT)) { zend_error(error_type, "%s::%s(): Return type must be %s when declared", - ZSTR_VAL(ce->name), ZSTR_VAL(fptr->common.function_name), + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(fptr->common.function_name), ZSTR_VAL(zend_type_to_string((zend_type) ZEND_TYPE_INIT_MASK(return_type)))); } } @@ -2727,7 +2742,7 @@ static void zend_check_magic_method_non_static( { if (fptr->common.fn_flags & ZEND_ACC_STATIC) { zend_error(error_type, "Method %s::%s() cannot be static", - ZSTR_VAL(ce->name), ZSTR_VAL(fptr->common.function_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(fptr->common.function_name)); } } @@ -2736,7 +2751,7 @@ static void zend_check_magic_method_static( { if (!(fptr->common.fn_flags & ZEND_ACC_STATIC)) { zend_error(error_type, "Method %s::%s() must be static", - ZSTR_VAL(ce->name), ZSTR_VAL(fptr->common.function_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(fptr->common.function_name)); } } @@ -2746,7 +2761,7 @@ static void zend_check_magic_method_public( // TODO: Remove this warning after adding proper visibility handling. if (!(fptr->common.fn_flags & ZEND_ACC_PUBLIC)) { zend_error(E_WARNING, "The magic method %s::%s() must have public visibility", - ZSTR_VAL(ce->name), ZSTR_VAL(fptr->common.function_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(fptr->common.function_name)); } } @@ -2755,7 +2770,7 @@ static void zend_check_magic_method_no_return_type( { if (fptr->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { zend_error_noreturn(error_type, "Method %s::%s() cannot declare a return type", - ZSTR_VAL(ce->name), ZSTR_VAL(fptr->common.function_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(fptr->common.function_name)); } } @@ -2978,7 +2993,7 @@ ZEND_API zend_result zend_register_functions(zend_class_entry *scope, const zend if (ptr->flags) { if (!(ptr->flags & ZEND_ACC_PPP_MASK)) { if (ptr->flags != ZEND_ACC_DEPRECATED && scope) { - zend_error(error_type, "Invalid access level for %s::%s() - access must be exactly one of public, protected or private", ZSTR_VAL(scope->name), ptr->fname); + zend_error(error_type, "Invalid access level for %s::%s() - access must be exactly one of public, protected or private", ZSTR_VAL(scope->namespaced_name.name), ptr->fname); } internal_function->fn_flags = ZEND_ACC_PUBLIC | ptr->flags; } else { @@ -3018,7 +3033,7 @@ ZEND_API zend_result zend_register_functions(zend_class_entry *scope, const zend } } else { zend_error(E_CORE_WARNING, "Missing arginfo for %s%s%s()", - scope ? ZSTR_VAL(scope->name) : "", scope ? "::" : "", ptr->fname); + scope ? ZSTR_VAL(scope->namespaced_name.name) : "", scope ? "::" : "", ptr->fname); internal_function->arg_info = NULL; internal_function->num_args = 0; @@ -3030,7 +3045,7 @@ ZEND_API zend_result zend_register_functions(zend_class_entry *scope, const zend if (scope && zend_string_equals_literal_ci(internal_function->function_name, "__tostring") && !(internal_function->fn_flags & ZEND_ACC_HAS_RETURN_TYPE)) { zend_error(E_CORE_WARNING, "%s::__toString() implemented without string return type", - ZSTR_VAL(scope->name)); + ZSTR_VAL(scope->namespaced_name.name)); internal_function->arg_info = (zend_internal_arg_info *) arg_info_toString + 1; internal_function->fn_flags |= ZEND_ACC_HAS_RETURN_TYPE; internal_function->num_args = internal_function->required_num_args = 0; @@ -3050,15 +3065,15 @@ ZEND_API zend_result zend_register_functions(zend_class_entry *scope, const zend } } if ((ptr->flags & ZEND_ACC_STATIC) && (!scope || !(scope->ce_flags & ZEND_ACC_INTERFACE))) { - zend_error(error_type, "Static function %s%s%s() cannot be abstract", scope ? ZSTR_VAL(scope->name) : "", scope ? "::" : "", ptr->fname); + zend_error(error_type, "Static function %s%s%s() cannot be abstract", scope ? ZSTR_VAL(scope->namespaced_name.name) : "", scope ? "::" : "", ptr->fname); } } else { if (scope && (scope->ce_flags & ZEND_ACC_INTERFACE)) { - zend_error(error_type, "Interface %s cannot contain non abstract method %s()", ZSTR_VAL(scope->name), ptr->fname); + zend_error(error_type, "Interface %s cannot contain non abstract method %s()", ZSTR_VAL(scope->namespaced_name.name), ptr->fname); return FAILURE; } if (!internal_function->handler) { - zend_error(error_type, "Method %s%s%s() cannot be a NULL function", scope ? ZSTR_VAL(scope->name) : "", scope ? "::" : "", ptr->fname); + zend_error(error_type, "Method %s%s%s() cannot be a NULL function", scope ? ZSTR_VAL(scope->namespaced_name.name) : "", scope ? "::" : "", ptr->fname); zend_unregister_functions(functions, count, target_function_table); return FAILURE; } @@ -3115,7 +3130,7 @@ ZEND_API zend_result zend_register_functions(zend_class_entry *scope, const zend if (!strcmp(arg_info->name, reg_function->arg_info[j].name)) { zend_error_noreturn(E_CORE_ERROR, "Duplicate parameter name $%s for function %s%s%s()", arg_info->name, - scope ? ZSTR_VAL(scope->name) : "", scope ? "::" : "", ptr->fname); + scope ? ZSTR_VAL(scope->namespaced_name.name) : "", scope ? "::" : "", ptr->fname); } } #endif @@ -3209,7 +3224,7 @@ ZEND_API zend_result zend_register_functions(zend_class_entry *scope, const zend lowercase_name = zend_string_alloc(fname_len, 0); zend_str_tolower_copy(ZSTR_VAL(lowercase_name), ptr->fname, fname_len); if (zend_hash_exists(target_function_table, lowercase_name)) { - zend_error(error_type, "Function registration failed - duplicate name - %s%s%s", scope ? ZSTR_VAL(scope->name) : "", scope ? "::" : "", ptr->fname); + zend_error(error_type, "Function registration failed - duplicate name - %s%s%s", scope ? ZSTR_VAL(scope->namespaced_name.name) : "", scope ? "::" : "", ptr->fname); } zend_string_efree(lowercase_name); ptr++; @@ -3475,7 +3490,7 @@ static zend_class_entry *do_register_internal_class(zend_class_entry *orig_class class_entry->type = ZEND_INTERNAL_CLASS; zend_initialize_class_data(class_entry, 0); - zend_alloc_ce_cache(class_entry->name); + zend_alloc_ce_cache(class_entry->namespaced_name.name); class_entry->ce_flags = orig_class_entry->ce_flags | ce_flags | ZEND_ACC_CONSTANTS_UPDATED | ZEND_ACC_LINKED | ZEND_ACC_RESOLVED_PARENT | ZEND_ACC_RESOLVED_INTERFACES; class_entry->info.internal.module = EG(current_module); @@ -3483,12 +3498,13 @@ static zend_class_entry *do_register_internal_class(zend_class_entry *orig_class zend_register_functions(class_entry, class_entry->info.internal.builtin_functions, &class_entry->function_table, EG(current_module)->type); } - lowercase_name = zend_string_tolower_ex(orig_class_entry->name, EG(current_module)->type == MODULE_PERSISTENT); + lowercase_name = zend_string_tolower_ex(orig_class_entry->namespaced_name.name, EG(current_module)->type == MODULE_PERSISTENT); lowercase_name = zend_new_interned_string(lowercase_name); + class_entry->namespaced_name.resolved_name = lowercase_name; zend_hash_update_ptr(CG(class_table), lowercase_name, class_entry); zend_string_release_ex(lowercase_name, 1); - if (class_entry->__tostring && !zend_string_equals_literal(class_entry->name, "Stringable") + if (class_entry->__tostring && !zend_string_equals_literal(class_entry->namespaced_name.name, "Stringable") && !(class_entry->ce_flags & ZEND_ACC_TRAIT)) { ZEND_ASSERT(zend_ce_stringable && "Should be registered before first class using __toString()"); @@ -3692,7 +3708,7 @@ static ZEND_COLD zend_object *display_disabled_class(zend_class_entry *class_typ } while (p != end); } - zend_error(E_WARNING, "%s() has been disabled for security reasons", ZSTR_VAL(class_type->name)); + zend_error(E_WARNING, "%s() has been disabled for security reasons", ZSTR_VAL(class_type->namespaced_name.name)); return intern; } #ifdef ZEND_WIN32 @@ -3947,13 +3963,13 @@ static zend_always_inline bool zend_is_callable_check_func(zval *callable, zend_ ftable = &fcc->calling_scope->function_table; if (ce_org && !instanceof_function(ce_org, fcc->calling_scope)) { - if (error) zend_spprintf(error, 0, "class %s is not a subclass of %s", ZSTR_VAL(ce_org->name), ZSTR_VAL(fcc->calling_scope->name)); + if (error) zend_spprintf(error, 0, "class %s is not a subclass of %s", ZSTR_VAL(ce_org->namespaced_name.name), ZSTR_VAL(fcc->calling_scope->namespaced_name.name)); return 0; } if (ce_org && !suppress_deprecation) { zend_error(E_DEPRECATED, "Callables of the form [\"%s\", \"%s\"] are deprecated", - ZSTR_VAL(ce_org->name), Z_STRVAL_P(callable)); + ZSTR_VAL(ce_org->namespaced_name.name), Z_STRVAL_P(callable)); } mname = zend_string_init(Z_STRVAL_P(callable) + clen + 2, mlen, 0); } else if (ce_org) { @@ -4057,12 +4073,12 @@ static zend_always_inline bool zend_is_callable_check_func(zval *callable, zend_ if (fcc->function_handler->common.fn_flags & ZEND_ACC_ABSTRACT) { retval = 0; if (error) { - zend_spprintf(error, 0, "cannot call abstract method %s::%s()", ZSTR_VAL(fcc->calling_scope->name), ZSTR_VAL(fcc->function_handler->common.function_name)); + zend_spprintf(error, 0, "cannot call abstract method %s::%s()", ZSTR_VAL(fcc->calling_scope->namespaced_name.name), ZSTR_VAL(fcc->function_handler->common.function_name)); } } else if (!fcc->object && !(fcc->function_handler->common.fn_flags & ZEND_ACC_STATIC)) { retval = 0; if (error) { - zend_spprintf(error, 0, "non-static method %s::%s() cannot be called statically", ZSTR_VAL(fcc->calling_scope->name), ZSTR_VAL(fcc->function_handler->common.function_name)); + zend_spprintf(error, 0, "non-static method %s::%s() cannot be called statically", ZSTR_VAL(fcc->calling_scope->namespaced_name.name), ZSTR_VAL(fcc->function_handler->common.function_name)); } } if (retval @@ -4075,7 +4091,7 @@ static zend_always_inline bool zend_is_callable_check_func(zval *callable, zend_ if (*error) { efree(*error); } - zend_spprintf(error, 0, "cannot access %s method %s::%s()", zend_visibility_string(fcc->function_handler->common.fn_flags), ZSTR_VAL(fcc->calling_scope->name), ZSTR_VAL(fcc->function_handler->common.function_name)); + zend_spprintf(error, 0, "cannot access %s method %s::%s()", zend_visibility_string(fcc->function_handler->common.fn_flags), ZSTR_VAL(fcc->calling_scope->namespaced_name.name), ZSTR_VAL(fcc->function_handler->common.function_name)); } retval = 0; } @@ -4084,7 +4100,7 @@ static zend_always_inline bool zend_is_callable_check_func(zval *callable, zend_ } } else if (error) { if (fcc->calling_scope) { - zend_spprintf(error, 0, "class %s does not have a method \"%s\"", ZSTR_VAL(fcc->calling_scope->name), ZSTR_VAL(mname)); + zend_spprintf(error, 0, "class %s does not have a method \"%s\"", ZSTR_VAL(fcc->calling_scope->namespaced_name.name), ZSTR_VAL(mname)); } else { zend_spprintf(error, 0, "function %s() does not exist", ZSTR_VAL(mname)); } @@ -4109,7 +4125,7 @@ ZEND_API zend_string *zend_get_callable_name_ex(zval *callable, zend_object *obj switch (Z_TYPE_P(callable)) { case IS_STRING: if (object) { - return zend_create_member_string(object->ce->name, Z_STR_P(callable)); + return zend_create_member_string(object->ce->namespaced_name.name, Z_STR_P(callable)); } return zend_string_copy(Z_STR_P(callable)); @@ -4130,7 +4146,7 @@ ZEND_API zend_string *zend_get_callable_name_ex(zval *callable, zend_object *obj if (Z_TYPE_P(obj) == IS_STRING) { return zend_create_member_string(Z_STR_P(obj), Z_STR_P(method)); } else if (Z_TYPE_P(obj) == IS_OBJECT) { - return zend_create_member_string(Z_OBJCE_P(obj)->name, Z_STR_P(method)); + return zend_create_member_string(Z_OBJCE_P(obj)->namespaced_name.name, Z_STR_P(method)); } else { return ZSTR_KNOWN(ZEND_STR_ARRAY_CAPITALIZED); } @@ -4144,7 +4160,7 @@ ZEND_API zend_string *zend_get_callable_name_ex(zval *callable, zend_object *obj if (fn->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) { if (fn->common.scope) { - return zend_create_member_string(fn->common.scope->name, fn->common.function_name); + return zend_create_member_string(fn->common.scope->namespaced_name.name, fn->common.function_name); } else { return zend_string_copy(fn->common.function_name); } @@ -4152,7 +4168,7 @@ ZEND_API zend_string *zend_get_callable_name_ex(zval *callable, zend_object *obj } return zend_string_concat2( - ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), + ZSTR_VAL(ce->namespaced_name.name), ZSTR_LEN(ce->namespaced_name.name), "::__invoke", sizeof("::__invoke") - 1); } case IS_REFERENCE: @@ -4310,7 +4326,7 @@ ZEND_API bool zend_make_callable(zval *callable, zend_string **callable_name) /* if (Z_TYPE_P(callable) == IS_STRING && fcc.calling_scope) { zval_ptr_dtor_str(callable); array_init(callable); - add_next_index_str(callable, zend_string_copy(fcc.calling_scope->name)); + add_next_index_str(callable, zend_string_copy(fcc.calling_scope->namespaced_name.name)); add_next_index_str(callable, zend_string_copy(fcc.function_handler->common.function_name)); } zend_release_fcall_info_cache(&fcc); @@ -4488,7 +4504,7 @@ ZEND_API void zend_get_callable_zval_from_fcc(const zend_fcall_info_cache *fcc, GC_ADDREF(fcc->object); add_next_index_object(callable, fcc->object); } else { - add_next_index_str(callable, zend_string_copy(fcc->calling_scope->name)); + add_next_index_str(callable, zend_string_copy(fcc->calling_scope->namespaced_name.name)); } add_next_index_str(callable, zend_string_copy(fcc->function_handler->common.function_name)); } else { @@ -4555,14 +4571,14 @@ ZEND_API zend_property_info *zend_declare_typed_property(zend_class_entry *ce, z if (!ZEND_TYPE_IS_SET(type)) { zend_error_noreturn(ce->type == ZEND_INTERNAL_CLASS ? E_CORE_ERROR : E_COMPILE_ERROR, "Property with asymmetric visibility %s::$%s must have type", - ZSTR_VAL(ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } uint32_t get_visibility = zend_visibility_to_set_visibility(access_type & ZEND_ACC_PPP_MASK); uint32_t set_visibility = access_type & ZEND_ACC_PPP_SET_MASK; if (get_visibility > set_visibility) { zend_error_noreturn(ce->type == ZEND_INTERNAL_CLASS ? E_CORE_ERROR : E_COMPILE_ERROR, "Visibility of property %s::$%s must not be weaker than set visibility", - ZSTR_VAL(ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } /* Remove equivalent set visibility. */ if (((access_type & (ZEND_ACC_PUBLIC|ZEND_ACC_PUBLIC_SET)) == (ZEND_ACC_PUBLIC|ZEND_ACC_PUBLIC_SET)) @@ -4649,7 +4665,7 @@ ZEND_API zend_property_info *zend_declare_typed_property(zend_class_entry *ce, z if (access_type & ZEND_ACC_PUBLIC) { property_info->name = zend_string_copy(name); } else if (access_type & ZEND_ACC_PRIVATE) { - property_info->name = zend_mangle_property_name(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), ZSTR_VAL(name), ZSTR_LEN(name), is_persistent_class(ce)); + property_info->name = zend_mangle_property_name(ZSTR_VAL(ce->namespaced_name.name), ZSTR_LEN(ce->namespaced_name.name), ZSTR_VAL(name), ZSTR_LEN(name), is_persistent_class(ce)); } else { ZEND_ASSERT(access_type & ZEND_ACC_PROTECTED); property_info->name = zend_mangle_property_name("*", 1, ZSTR_VAL(name), ZSTR_LEN(name), is_persistent_class(ce)); @@ -4874,7 +4890,7 @@ ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry if (ce->ce_flags & ZEND_ACC_INTERFACE) { if (!(flags & ZEND_ACC_PUBLIC)) { - zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface constant %s::%s must be public", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface constant %s::%s must be public", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } } @@ -4912,7 +4928,7 @@ ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry if (!zend_hash_add_ptr(&ce->constants_table, name, c)) { zend_error_noreturn(ce->type == ZEND_INTERNAL_CLASS ? E_CORE_ERROR : E_COMPILE_ERROR, - "Cannot redefine class constant %s::%s", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + "Cannot redefine class constant %s::%s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } return c; diff --git a/Zend/zend_API.h b/Zend/zend_API.h index 6aeffce25d8e5..51cf05493b375 100644 --- a/Zend/zend_API.h +++ b/Zend/zend_API.h @@ -277,12 +277,30 @@ typedef struct _zend_fcall_info_cache { #endif #define INIT_CLASS_ENTRY(class_container, class_name, functions) \ - INIT_CLASS_ENTRY_EX(class_container, class_name, strlen(class_name), functions) + INIT_CLASS_ENTRY_EX(class_container, class_name, functions) -#define INIT_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions) \ +#define INIT_CLASS_NAME(n, class_name) \ + INIT_CLASS_NAME_EX("", 0, n, class_name, strlen(class_name)) + +#define INIT_CLASS_NAME_NS(n, ns, class_name) \ + INIT_CLASS_NAME_EX(ns, strlen(ns), n, ZEND_NS_NAME(ns, class_name), strlen(ZEND_NS_NAME(ns, class_name))) + +#define INIT_CLASS_NAME_EX(ns, ns_len, n, class_name, class_name_len) \ + { \ + memset(&n, 0, sizeof(zend_namespaced_name)); \ + n.name = zend_string_init_interned(class_name, class_name_len, 1); \ + n.kind = ZEND_NAME_NAMESPACE; \ + if (strlen(ns) == 0) { \ + n.namespace_name = zend_empty_string; \ + } else { \ + n.namespace_name = zend_string_init_interned(ns, ns_len, 1); \ + } \ + } + +#define INIT_CLASS_ENTRY_EX(class_container, class_name, functions) \ { \ memset(&class_container, 0, sizeof(zend_class_entry)); \ - class_container.name = zend_string_init_interned(class_name, class_name_len, 1); \ + class_container.namespaced_name = class_name; \ class_container.default_object_handlers = &std_object_handlers; \ class_container.info.internal.builtin_functions = functions; \ } @@ -1772,7 +1790,7 @@ ZEND_API ZEND_COLD void zend_class_redeclaration_error_ex(int type, zend_string Z_PARAM_PROLOGUE(0, 0); \ if (UNEXPECTED(!zend_parse_arg_obj_or_str(_arg, &destination_object, base_ce, &destination_string, allow_null, _i))) { \ if (base_ce) { \ - _error = ZSTR_VAL((base_ce)->name); \ + _error = ZSTR_VAL((base_ce)->namespaced_name.name); \ _error_code = allow_null ? ZPP_ERROR_WRONG_CLASS_OR_STRING_OR_NULL : ZPP_ERROR_WRONG_CLASS_OR_STRING; \ break; \ } else { \ @@ -1960,7 +1978,7 @@ ZEND_API ZEND_COLD void zend_class_redeclaration_error_ex(int type, zend_string Z_PARAM_PROLOGUE(deref, 0); \ if (UNEXPECTED(!zend_parse_arg_object(_arg, &dest, _ce, check_null))) { \ if (_ce) { \ - _error = ZSTR_VAL((_ce)->name); \ + _error = ZSTR_VAL((_ce)->namespaced_name.name); \ _error_code = check_null ? ZPP_ERROR_WRONG_CLASS_OR_NULL : ZPP_ERROR_WRONG_CLASS; \ break; \ } else { \ @@ -1981,7 +1999,7 @@ ZEND_API ZEND_COLD void zend_class_redeclaration_error_ex(int type, zend_string Z_PARAM_PROLOGUE(deref, 0); \ if (UNEXPECTED(!zend_parse_arg_obj(_arg, &dest, _ce, check_null))) { \ if (_ce) { \ - _error = ZSTR_VAL((_ce)->name); \ + _error = ZSTR_VAL((_ce)->namespaced_name.name); \ _error_code = check_null ? ZPP_ERROR_WRONG_CLASS_OR_NULL : ZPP_ERROR_WRONG_CLASS; \ break; \ } else { \ @@ -2000,7 +2018,7 @@ ZEND_API ZEND_COLD void zend_class_redeclaration_error_ex(int type, zend_string #define Z_PARAM_OBJ_OF_CLASS_OR_LONG_EX(dest_obj, _ce, dest_long, is_null, allow_null) \ Z_PARAM_PROLOGUE(0, 0); \ if (UNEXPECTED(!zend_parse_arg_obj_or_long(_arg, &dest_obj, _ce, &dest_long, &is_null, allow_null, _i))) { \ - _error = ZSTR_VAL((_ce)->name); \ + _error = ZSTR_VAL((_ce)->namespaced_name.name); \ _error_code = allow_null ? ZPP_ERROR_WRONG_CLASS_OR_LONG_OR_NULL : ZPP_ERROR_WRONG_CLASS_OR_LONG; \ break; \ } diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index 8b0a66fda8096..5e496a024747e 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -661,7 +661,7 @@ ZEND_API zend_result ZEND_FASTCALL zend_ast_evaluate_inner( } case ZEND_AST_CONSTANT_CLASS: if (scope) { - ZVAL_STR_COPY(result, scope->name); + ZVAL_STR_COPY(result, scope->namespaced_name.name); } else { ZVAL_EMPTY_STRING(result); } @@ -672,14 +672,14 @@ ZEND_API zend_result ZEND_FASTCALL zend_ast_evaluate_inner( return FAILURE; } if (ast->attr == ZEND_FETCH_CLASS_SELF) { - ZVAL_STR_COPY(result, scope->name); + ZVAL_STR_COPY(result, scope->namespaced_name.name); } else if (ast->attr == ZEND_FETCH_CLASS_PARENT) { if (!scope->parent) { zend_throw_error(NULL, "Cannot use \"parent\" when current class scope has no parent"); return FAILURE; } - ZVAL_STR_COPY(result, scope->parent->name); + ZVAL_STR_COPY(result, scope->parent->namespaced_name.name); } else { ZEND_ASSERT(0 && "Should have errored during compilation"); } @@ -1091,18 +1091,18 @@ ZEND_API zend_result ZEND_FASTCALL zend_ast_evaluate_inner( if (!(fptr->common.fn_flags & ZEND_ACC_STATIC)) { zend_non_static_method_call(fptr); - + return FAILURE; } if ((fptr->common.fn_flags & ZEND_ACC_ABSTRACT)) { zend_abstract_method_call(fptr); - + return FAILURE; } else if (fptr->common.scope->ce_flags & ZEND_ACC_TRAIT) { zend_error(E_DEPRECATED, "Calling static trait method %s::%s is deprecated, " "it should only be called on a class using the trait", - ZSTR_VAL(fptr->common.scope->name), ZSTR_VAL(fptr->common.function_name)); + ZSTR_VAL(fptr->common.scope->namespaced_name.name), ZSTR_VAL(fptr->common.function_name)); if (EG(exception)) { return FAILURE; } diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index d0dad8490c4e3..2bf4638f0348e 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -133,6 +133,7 @@ enum _zend_ast_kind { ZEND_AST_YIELD, ZEND_AST_COALESCE, ZEND_AST_ASSIGN_COALESCE, + ZEND_AST_INNER_CLASS, ZEND_AST_STATIC, ZEND_AST_WHILE, diff --git a/Zend/zend_attributes.c b/Zend/zend_attributes.c index d7bcb1f54e889..74f28a6b66df1 100644 --- a/Zend/zend_attributes.c +++ b/Zend/zend_attributes.c @@ -73,22 +73,22 @@ static void validate_allow_dynamic_properties( { if (scope->ce_flags & ZEND_ACC_TRAIT) { zend_error_noreturn(E_ERROR, "Cannot apply #[AllowDynamicProperties] to trait %s", - ZSTR_VAL(scope->name) + ZSTR_VAL(scope->namespaced_name.name) ); } if (scope->ce_flags & ZEND_ACC_INTERFACE) { zend_error_noreturn(E_ERROR, "Cannot apply #[AllowDynamicProperties] to interface %s", - ZSTR_VAL(scope->name) + ZSTR_VAL(scope->namespaced_name.name) ); } if (scope->ce_flags & ZEND_ACC_READONLY_CLASS) { zend_error_noreturn(E_ERROR, "Cannot apply #[AllowDynamicProperties] to readonly class %s", - ZSTR_VAL(scope->name) + ZSTR_VAL(scope->namespaced_name.name) ); } if (scope->ce_flags & ZEND_ACC_ENUM) { zend_error_noreturn(E_ERROR, "Cannot apply #[AllowDynamicProperties] to enum %s", - ZSTR_VAL(scope->name) + ZSTR_VAL(scope->namespaced_name.name) ); } scope->ce_flags |= ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES; @@ -459,13 +459,13 @@ ZEND_API zend_internal_attribute *zend_mark_internal_attribute(zend_class_entry } ZEND_HASH_FOREACH_PTR(ce->attributes, attr) { - if (zend_string_equals(attr->name, zend_ce_attribute->name)) { + if (zend_string_equals(attr->name, zend_ce_attribute->namespaced_name.name)) { internal_attr = pemalloc(sizeof(zend_internal_attribute), 1); internal_attr->ce = ce; internal_attr->flags = Z_LVAL(attr->args[0].value); internal_attr->validator = NULL; - zend_string *lcname = zend_string_tolower_ex(ce->name, 1); + zend_string *lcname = zend_string_tolower_ex(ce->namespaced_name.name, 1); zend_hash_update_ptr(&internal_attributes, lcname, internal_attr); zend_string_release(lcname); @@ -478,7 +478,7 @@ ZEND_API zend_internal_attribute *zend_mark_internal_attribute(zend_class_entry ZEND_API zend_internal_attribute *zend_internal_attribute_register(zend_class_entry *ce, uint32_t flags) { - zend_attribute *attr = zend_add_class_attribute(ce, zend_ce_attribute->name, 1); + zend_attribute *attr = zend_add_class_attribute(ce, zend_ce_attribute->namespaced_name.name, 1); ZVAL_LONG(&attr->args[0].value, flags); return zend_mark_internal_attribute(ce); @@ -486,6 +486,13 @@ ZEND_API zend_internal_attribute *zend_internal_attribute_register(zend_class_en ZEND_API zend_internal_attribute *zend_internal_attribute_get(zend_string *lcname) { + const char *inner = strrchr(ZSTR_VAL(lcname), '|'); + if (inner) { + lcname = zend_string_init(inner + 1, strlen(inner) - 1, 0); + zend_internal_attribute *attr = zend_internal_attribute_get(lcname); + zend_string_release(lcname); + return attr; + } return zend_hash_find_ptr(&internal_attributes, lcname); } diff --git a/Zend/zend_attributes_arginfo.h b/Zend/zend_attributes_arginfo.h index 018caa47d0ac5..21f0030aea0a2 100644 --- a/Zend/zend_attributes_arginfo.h +++ b/Zend/zend_attributes_arginfo.h @@ -79,8 +79,10 @@ static const zend_function_entry class_Deprecated_methods[] = { static zend_class_entry *register_class_Attribute(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Attribute", class_Attribute_methods); + INIT_CLASS_NAME(namespaced_name, "Attribute"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Attribute_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zval const_TARGET_CLASS_value; @@ -150,8 +152,10 @@ static zend_class_entry *register_class_Attribute(void) static zend_class_entry *register_class_ReturnTypeWillChange(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReturnTypeWillChange", class_ReturnTypeWillChange_methods); + INIT_CLASS_NAME(namespaced_name, "ReturnTypeWillChange"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReturnTypeWillChange_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zend_string *attribute_name_Attribute_class_ReturnTypeWillChange_0 = zend_string_init_interned("Attribute", sizeof("Attribute") - 1, 1); @@ -167,8 +171,10 @@ static zend_class_entry *register_class_ReturnTypeWillChange(void) static zend_class_entry *register_class_AllowDynamicProperties(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "AllowDynamicProperties", class_AllowDynamicProperties_methods); + INIT_CLASS_NAME(namespaced_name, "AllowDynamicProperties"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_AllowDynamicProperties_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zend_string *attribute_name_Attribute_class_AllowDynamicProperties_0 = zend_string_init_interned("Attribute", sizeof("Attribute") - 1, 1); @@ -184,8 +190,10 @@ static zend_class_entry *register_class_AllowDynamicProperties(void) static zend_class_entry *register_class_SensitiveParameter(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SensitiveParameter", class_SensitiveParameter_methods); + INIT_CLASS_NAME(namespaced_name, "SensitiveParameter"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SensitiveParameter_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES); zend_string *attribute_name_Attribute_class_SensitiveParameter_0 = zend_string_init_interned("Attribute", sizeof("Attribute") - 1, 1); @@ -201,8 +209,10 @@ static zend_class_entry *register_class_SensitiveParameter(void) static zend_class_entry *register_class_SensitiveParameterValue(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SensitiveParameterValue", class_SensitiveParameterValue_methods); + INIT_CLASS_NAME(namespaced_name, "SensitiveParameterValue"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SensitiveParameterValue_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zval property_value_default_value; @@ -215,8 +225,10 @@ static zend_class_entry *register_class_SensitiveParameterValue(void) static zend_class_entry *register_class_Override(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Override", class_Override_methods); + INIT_CLASS_NAME(namespaced_name, "Override"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Override_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES); zend_string *attribute_name_Attribute_class_Override_0 = zend_string_init_interned("Attribute", sizeof("Attribute") - 1, 1); @@ -232,8 +244,10 @@ static zend_class_entry *register_class_Override(void) static zend_class_entry *register_class_Deprecated(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Deprecated", class_Deprecated_methods); + INIT_CLASS_NAME(namespaced_name, "Deprecated"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Deprecated_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES); zval property_message_default_value; diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index 57ecd1964a7f3..3f9b610d30906 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -592,14 +592,14 @@ ZEND_FUNCTION(get_class) if (UNEXPECTED(EG(exception))) { RETURN_THROWS(); } - RETURN_STR_COPY(scope->name); + RETURN_STR_COPY(scope->namespaced_name.name); } else { zend_throw_error(NULL, "get_class() without arguments must be called from within a class"); RETURN_THROWS(); } } - RETURN_STR_COPY(Z_OBJCE_P(obj)->name); + RETURN_STR_COPY(Z_OBJCE_P(obj)->namespaced_name.name); } /* }}} */ @@ -616,7 +616,7 @@ ZEND_FUNCTION(get_called_class) RETURN_THROWS(); } - RETURN_STR_COPY(called_scope->name); + RETURN_STR_COPY(called_scope->namespaced_name.name); } /* }}} */ @@ -639,7 +639,7 @@ ZEND_FUNCTION(get_parent_class) } if (ce && ce->parent) { - RETURN_STR_COPY(ce->parent->name); + RETURN_STR_COPY(ce->parent->namespaced_name.name); } else { RETURN_FALSE; } @@ -679,7 +679,7 @@ static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, bool only_subclass) /* {{{ * RETURN_FALSE; } - if (!only_subclass && EXPECTED(zend_string_equals(instance_ce->name, class_name))) { + if (!only_subclass && EXPECTED(zend_string_equals(instance_ce->namespaced_name.name, class_name))) { retval = 1; } else { ce = zend_lookup_class_ex(class_name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD); @@ -1386,7 +1386,7 @@ static inline void get_declared_class_impl(INTERNAL_FUNCTION_PARAMETERS, int fla && ZSTR_VAL(key)[0] != 0) { ZEND_HASH_FILL_GROW(); if (EXPECTED(Z_TYPE_P(zv) == IS_PTR)) { - ZEND_HASH_FILL_SET_STR_COPY(ce->name); + ZEND_HASH_FILL_SET_STR_COPY(ce->namespaced_name.name); } else { ZEND_ASSERT(Z_TYPE_P(zv) == IS_ALIAS_PTR); ZEND_HASH_FILL_SET_STR_COPY(key); @@ -2042,9 +2042,9 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int object = Z_OBJ(call->This); /* $this may be passed into regular internal functions */ if (func->common.scope) { - ZVAL_STR_COPY(&tmp, func->common.scope->name); + ZVAL_STR_COPY(&tmp, func->common.scope->namespaced_name.name); } else if (object->handlers->get_class_name == zend_std_get_class_name) { - ZVAL_STR_COPY(&tmp, object->ce->name); + ZVAL_STR_COPY(&tmp, object->ce->namespaced_name.name); } else { ZVAL_STR(&tmp, object->handlers->get_class_name(object)); } @@ -2057,7 +2057,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int ZVAL_INTERNED_STR(&tmp, ZSTR_KNOWN(ZEND_STR_OBJECT_OPERATOR)); _zend_hash_append_ex(stack_frame, ZSTR_KNOWN(ZEND_STR_TYPE), &tmp, 1); } else if (func->common.scope) { - ZVAL_STR_COPY(&tmp, func->common.scope->name); + ZVAL_STR_COPY(&tmp, func->common.scope->namespaced_name.name); _zend_hash_append_ex(stack_frame, ZSTR_KNOWN(ZEND_STR_CLASS), &tmp, 1); ZVAL_INTERNED_STR(&tmp, ZSTR_KNOWN(ZEND_STR_PAAMAYIM_NEKUDOTAYIM)); _zend_hash_append_ex(stack_frame, ZSTR_KNOWN(ZEND_STR_TYPE), &tmp, 1); diff --git a/Zend/zend_builtin_functions_arginfo.h b/Zend/zend_builtin_functions_arginfo.h index cf34b1c0012d5..f7eeb8b663c3d 100644 --- a/Zend/zend_builtin_functions_arginfo.h +++ b/Zend/zend_builtin_functions_arginfo.h @@ -367,8 +367,10 @@ static const zend_function_entry ext_functions[] = { static zend_class_entry *register_class_stdClass(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "stdClass", NULL); + INIT_CLASS_NAME(namespaced_name, "stdClass"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES); zend_string *attribute_name_AllowDynamicProperties_class_stdClass_0 = zend_string_init_interned("AllowDynamicProperties", sizeof("AllowDynamicProperties") - 1, 1); diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c index e9945b3284cd9..5e7c89c107865 100644 --- a/Zend/zend_closures.c +++ b/Zend/zend_closures.c @@ -89,9 +89,9 @@ static bool zend_valid_closure_binding( !instanceof_function(Z_OBJCE_P(newthis), func->common.scope)) { /* Binding incompatible $this to an internal method is not supported. */ zend_error(E_WARNING, "Cannot bind method %s::%s() to object of class %s", - ZSTR_VAL(func->common.scope->name), + ZSTR_VAL(func->common.scope->namespaced_name.name), ZSTR_VAL(func->common.function_name), - ZSTR_VAL(Z_OBJCE_P(newthis)->name)); + ZSTR_VAL(Z_OBJCE_P(newthis)->namespaced_name.name)); return 0; } } else if (is_fake_closure && func->common.scope @@ -107,7 +107,7 @@ static bool zend_valid_closure_binding( if (scope && scope != func->common.scope && scope->type == ZEND_INTERNAL_CLASS) { /* rebinding to internal class is not allowed */ zend_error(E_WARNING, "Cannot bind closure to scope of internal class %s", - ZSTR_VAL(scope->name)); + ZSTR_VAL(scope->namespaced_name.name)); return 0; } @@ -597,7 +597,7 @@ static HashTable *zend_closure_get_debug_info(zend_object *object, int *is_temp) if (closure->func.op_array.fn_flags & ZEND_ACC_FAKE_CLOSURE) { if (closure->func.common.scope) { - zend_string *class_name = closure->func.common.scope->name; + zend_string *class_name = closure->func.common.scope->namespaced_name.name; zend_string *func_name = closure->func.common.function_name; zend_string *combined = zend_string_concat3( ZSTR_VAL(class_name), ZSTR_LEN(class_name), diff --git a/Zend/zend_closures_arginfo.h b/Zend/zend_closures_arginfo.h index 57066078a8821..c248b44c05afa 100644 --- a/Zend/zend_closures_arginfo.h +++ b/Zend/zend_closures_arginfo.h @@ -42,8 +42,10 @@ static const zend_function_entry class_Closure_methods[] = { static zend_class_entry *register_class_Closure(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Closure", class_Closure_methods); + INIT_CLASS_NAME(namespaced_name, "Closure"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Closure_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index cd0ac6eb07b9c..9c815160ae711 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -893,12 +893,12 @@ uint32_t zend_modifier_token_to_flag(zend_modifier_target target, uint32_t token } break; case T_READONLY: - if (target == ZEND_MODIFIER_TARGET_PROPERTY || target == ZEND_MODIFIER_TARGET_CPP) { + if (target == ZEND_MODIFIER_TARGET_PROPERTY || target == ZEND_MODIFIER_TARGET_CPP || target == ZEND_MODIFIER_TARGET_INNER_CLASS) { return ZEND_ACC_READONLY; } break; case T_ABSTRACT: - if (target == ZEND_MODIFIER_TARGET_METHOD || target == ZEND_MODIFIER_TARGET_PROPERTY) { + if (target == ZEND_MODIFIER_TARGET_METHOD || target == ZEND_MODIFIER_TARGET_PROPERTY || target == ZEND_MODIFIER_TARGET_INNER_CLASS) { return ZEND_ACC_ABSTRACT; } break; @@ -906,6 +906,7 @@ uint32_t zend_modifier_token_to_flag(zend_modifier_target target, uint32_t token if (target == ZEND_MODIFIER_TARGET_METHOD || target == ZEND_MODIFIER_TARGET_CONSTANT || target == ZEND_MODIFIER_TARGET_PROPERTY + || target == ZEND_MODIFIER_TARGET_INNER_CLASS || target == ZEND_MODIFIER_TARGET_PROPERTY_HOOK) { return ZEND_ACC_FINAL; } @@ -943,6 +944,8 @@ uint32_t zend_modifier_token_to_flag(zend_modifier_target target, uint32_t token member = "parameter"; } else if (target == ZEND_MODIFIER_TARGET_PROPERTY_HOOK) { member = "property hook"; + } else if (target == ZEND_MODIFIER_TARGET_INNER_CLASS) { + member = "inner class"; } else { ZEND_UNREACHABLE(); } @@ -1050,6 +1053,37 @@ uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag, zend_modifi return 0; } } + if (target == ZEND_MODIFIER_TARGET_INNER_CLASS) { + if ((flags & ZEND_ACC_PPP_MASK) && (new_flag & ZEND_ACC_PPP_MASK)) { + zend_throw_exception(zend_ce_compile_error, + "Multiple access type modifiers are not allowed", 0); + return 0; + } + + if ((flags & ZEND_ACC_STATIC) || (new_flag & ZEND_ACC_STATIC)) { + zend_throw_exception(zend_ce_compile_error, + "Static inner classes are not allowed", 0); + return 0; + } + + if ((flags & ZEND_ACC_PUBLIC_SET) || (new_flag & ZEND_ACC_PUBLIC_SET)) { + zend_throw_exception(zend_ce_compile_error, + "Public(set) inner classes are not allowed", 0); + return 0; + } + + if ((flags & ZEND_ACC_PROTECTED_SET) || (new_flag & ZEND_ACC_PROTECTED_SET)) { + zend_throw_exception(zend_ce_compile_error, + "Protected(set) inner classes are not allowed", 0); + return 0; + } + + if ((flags & ZEND_ACC_PRIVATE_SET) || (new_flag & ZEND_ACC_PRIVATE_SET)) { + zend_throw_exception(zend_ce_compile_error, + "Private(set) inner classes are not allowed", 0); + return 0; + } + } return new_flags; } /* }}} */ @@ -1065,6 +1099,15 @@ static zend_string *zend_concat_names(char *name1, size_t name1_len, char *name2 return zend_string_concat3(name1, name1_len, "\\", 1, name2, name2_len); } +static zend_string *zend_prefix_with_outer_class(zend_string *name) { + ZEND_ASSERT(CG(active_class_entry)); + + zend_string *ns = CG(active_class_entry)->namespaced_name.name; + + // encode the orginal scope + return zend_string_concat3(ZSTR_VAL(ns), ZSTR_LEN(ns), "|", 1, ZSTR_VAL(name), ZSTR_LEN(name)); +} + static zend_string *zend_prefix_with_ns(zend_string *name) { if (FC(current_namespace)) { zend_string *ns = FC(current_namespace); @@ -1144,9 +1187,10 @@ static zend_string *zend_resolve_const_name(zend_string *name, uint32_t type, bo name, type, is_fully_qualified, 1, FC(imports_const)); } -static zend_string *zend_resolve_class_name(zend_string *name, uint32_t type) /* {{{ */ +static zend_namespaced_name *zend_resolve_class_name(zend_string *name, uint32_t type) /* {{{ */ { char *compound; + zend_namespaced_name *actual_name = NULL; if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) { if (type == ZEND_NAME_FQ) { @@ -1158,11 +1202,13 @@ static zend_string *zend_resolve_class_name(zend_string *name, uint32_t type) /* "'namespace\\%s' is an invalid class name", ZSTR_VAL(name)); } ZEND_ASSERT(type == ZEND_NAME_NOT_FQ); - return zend_string_copy(name); + return actual_name; + //return zend_string_copy(name); } if (type == ZEND_NAME_RELATIVE) { - return zend_prefix_with_ns(name); + return actual_name; + //return zend_prefix_with_ns(name); } if (type == ZEND_NAME_FQ) { @@ -1173,10 +1219,12 @@ static zend_string *zend_resolve_class_name(zend_string *name, uint32_t type) /* zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", ZSTR_VAL(name)); } - return name; + return actual_name; + //return name; } - return zend_string_copy(name); + return actual_name; + //return zend_string_copy(name); } if (FC(imports)) { @@ -1188,8 +1236,9 @@ static zend_string *zend_resolve_class_name(zend_string *name, uint32_t type) /* zend_hash_str_find_ptr_lc(FC(imports), ZSTR_VAL(name), len); if (import_name) { - return zend_concat_names( - ZSTR_VAL(import_name), ZSTR_LEN(import_name), ZSTR_VAL(name) + len + 1, ZSTR_LEN(name) - len - 1); + return actual_name; + //return zend_concat_names( + // ZSTR_VAL(import_name), ZSTR_LEN(import_name), ZSTR_VAL(name) + len + 1, ZSTR_LEN(name) - len - 1); } } else { /* If an unqualified name is an alias, replace it. */ @@ -1197,17 +1246,24 @@ static zend_string *zend_resolve_class_name(zend_string *name, uint32_t type) /* = zend_hash_find_ptr_lc(FC(imports), name); if (import_name) { - return zend_string_copy(import_name); + return actual_name; + //return zend_string_copy(import_name); } } } + if (CG(active_class_entry)) { + return actual_name; + //return zend_prefix_with_outer_class(name); + } + /* If not fully qualified and not an alias, prepend the current namespace */ - return zend_prefix_with_ns(name); + return actual_name; + //return zend_prefix_with_ns(name); } /* }}} */ -static zend_string *zend_resolve_class_name_ast(zend_ast *ast) /* {{{ */ +static zend_namespaced_name *zend_resolve_class_name_ast(zend_ast *ast) /* {{{ */ { zval *class_name = zend_ast_get_zval(ast); if (Z_TYPE_P(class_name) != IS_STRING) { @@ -1390,12 +1446,18 @@ static zend_string *add_type_string(zend_string *type, zend_string *new_type, bo static zend_string *resolve_class_name(zend_string *name, zend_class_entry *scope) { if (scope) { if (zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_SELF))) { - name = scope->name; + name = scope->namespaced_name.name; } else if (zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_PARENT)) && scope->parent) { - name = scope->parent->name; + name = scope->parent->namespaced_name.name; } } + char *nested = strrchr(ZSTR_VAL(name), '|'); + if (nested) { + /* The original scope is encoded in the name. */ + return zend_string_init(nested + 1, ZSTR_LEN(name) - (nested - ZSTR_VAL(name)) - 1, 0); + } + /* The resolved name for anonymous classes contains null bytes. Cut off everything after the * null byte here, to avoid larger parts of the type being omitted by printing code later. */ size_t len = strlen(ZSTR_VAL(name)); @@ -1472,7 +1534,7 @@ zend_string *zend_type_to_string_resolved(zend_type type, zend_class_entry *scop if (scope && !zend_is_compiling()) { zend_class_entry *called_scope = zend_get_called_scope(EG(current_execute_data)); if (called_scope) { - name = called_scope->name; + name = called_scope->namespaced_name.name; } } str = add_type_string(str, name, /* is_intersection */ false); @@ -1731,7 +1793,7 @@ static inline bool class_name_refers_to_active_ce(zend_string *class_name, uint3 return 1; } return fetch_type == ZEND_FETCH_CLASS_DEFAULT - && zend_string_equals_ci(class_name, CG(active_class_entry)->name); + && zend_string_equals_ci(class_name, CG(active_class_entry)->namespaced_name.name); } /* }}} */ @@ -1760,7 +1822,40 @@ static uint32_t zend_get_class_fetch_type_ast(zend_ast *name_ast) /* {{{ */ } /* }}} */ -static zend_string *zend_resolve_const_class_name_reference(zend_ast *ast, const char *type) +static bool zend_try_compile_const_expr_resolve_class_name(zval *zv, zend_ast *class_ast); + +static zend_string *zend_resolve_nested_class_name(zend_ast *ast) /* {{{ */ +{ + ZEND_ASSERT(ast->kind == ZEND_AST_INNER_CLASS); + + zend_ast *outer_class = ast->child[0]; + zend_ast *inner_class = ast->child[1]; + + zend_string *outer_name, *inner_name, *full_name; + + if (outer_class->kind == ZEND_AST_INNER_CLASS) { + outer_name = zend_resolve_nested_class_name(outer_class); + } else { + zval outer_class_name; + zend_try_compile_const_expr_resolve_class_name(&outer_class_name, outer_class); + outer_name = Z_STR(outer_class_name); + } + + inner_name = zend_ast_get_str(inner_class); + + full_name = zend_string_concat3( + ZSTR_VAL(outer_name), ZSTR_LEN(outer_name), + ":>", 2, + ZSTR_VAL(inner_name), ZSTR_LEN(inner_name) + ); + + zend_string_release(outer_name); + + return full_name; +} +/* }}} */ + +static zend_namespaced_name *zend_resolve_const_class_name_reference(zend_ast *ast, const char *type) { zend_string *class_name = zend_ast_get_str(ast); if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type_ast(ast)) { @@ -1792,6 +1887,11 @@ static bool zend_try_compile_const_expr_resolve_class_name(zval *zv, zend_ast *c uint32_t fetch_type; zval *class_name; + if (class_ast->kind == ZEND_AST_INNER_CLASS) { + ZVAL_STR(zv, zend_resolve_nested_class_name(class_ast)); + return 1; + } + if (class_ast->kind != ZEND_AST_ZVAL) { return 0; } @@ -1808,14 +1908,14 @@ static bool zend_try_compile_const_expr_resolve_class_name(zval *zv, zend_ast *c switch (fetch_type) { case ZEND_FETCH_CLASS_SELF: if (CG(active_class_entry) && zend_is_scope_known()) { - ZVAL_STR_COPY(zv, CG(active_class_entry)->name); + ZVAL_STR_COPY(zv, CG(active_class_entry)->namespaced_name.name); return 1; } return 0; case ZEND_FETCH_CLASS_PARENT: if (CG(active_class_entry) && CG(active_class_entry)->parent_name && zend_is_scope_known()) { - ZVAL_STR_COPY(zv, CG(active_class_entry)->parent_name); + ZVAL_STR_COPY(zv, CG(active_class_entry)->parent_name->name); return 1; } return 0; @@ -1855,7 +1955,7 @@ static bool zend_verify_ct_const_access(zend_class_constant *c, zend_class_entry if (ce->ce_flags & ZEND_ACC_RESOLVED_PARENT) { ce = ce->parent; } else { - ce = zend_hash_find_ptr_lc(CG(class_table), ce->parent_name); + ce = zend_hash_find_ptr_lc(CG(class_table), ce->parent_name->name); if (!ce) { break; } @@ -2844,10 +2944,42 @@ static inline void zend_set_class_name_op1(zend_op *opline, znode *class_node) / } /* }}} */ +static void zend_compile_class_ref(znode *result, zend_ast *name_ast, uint32_t fetch_flags); + +static void zend_compile_inner_class_ref(znode *result, zend_ast *ast, uint32_t fetch_flags) /* {{{ */ +{ + zend_ast *outer_class = ast->child[0]; + zend_ast *inner_class = ast->child[1]; + + znode outer_node, inner_node; + + // handle nesting + if (outer_class->kind == ZEND_AST_INNER_CLASS) { + zend_compile_inner_class_ref(&outer_node, outer_class, fetch_flags); + } else { + zend_compile_class_ref(&outer_node, outer_class, fetch_flags | ZEND_FETCH_CLASS_OUTER); + } + + if (inner_class->kind == ZEND_AST_ZVAL && Z_TYPE_P(zend_ast_get_zval(inner_class)) == IS_STRING) { + ZVAL_STR(&inner_node.u.constant, zend_string_dup(Z_STR_P(zend_ast_get_zval(inner_class)), 0)); + inner_node.op_type = IS_CONST; + } else { + zend_compile_expr(&inner_node, inner_class); + } + + zend_emit_op(result, ZEND_FETCH_INNER_CLASS, &outer_node, &inner_node); +} +/* }}} */ + static void zend_compile_class_ref(znode *result, zend_ast *name_ast, uint32_t fetch_flags) /* {{{ */ { uint32_t fetch_type; + if (name_ast->kind == ZEND_AST_INNER_CLASS) { + zend_compile_inner_class_ref(result, name_ast, fetch_flags); + return; + } + if (name_ast->kind != ZEND_AST_ZVAL) { znode name_node; @@ -2891,10 +3023,12 @@ static void zend_compile_class_ref(znode *result, zend_ast *name_ast, uint32_t f if (ZEND_FETCH_CLASS_DEFAULT == fetch_type) { result->op_type = IS_CONST; ZVAL_STR(&result->u.constant, zend_resolve_class_name_ast(name_ast)); + } else if (fetch_flags & ZEND_FETCH_CLASS_OUTER && fetch_type == ZEND_FETCH_CLASS_STATIC) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the static modifier on an inner class"); } else { zend_ensure_valid_class_fetch_type(fetch_type); result->op_type = IS_UNUSED; - result->u.op.num = fetch_type | fetch_flags; + result->u.op.num = fetch_type | (fetch_flags & ~ZEND_FETCH_CLASS_OUTER); } } /* }}} */ @@ -5364,7 +5498,7 @@ static void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type ce = NULL; } } else if (CG(active_class_entry) - && zend_string_equals_ci(CG(active_class_entry)->name, lcname)) { + && zend_string_equals_ci(CG(active_class_entry)->namespaced_name.name, lcname)) { ce = CG(active_class_entry); } } else if (opline->op1_type == IS_UNUSED @@ -6997,14 +7131,14 @@ static zend_type zend_compile_single_typename(zend_ast *ast) if (fetch_type == ZEND_FETCH_CLASS_SELF) { /* Scope might be unknown for unbound closures and traits */ if (zend_is_scope_known()) { - class_name = CG(active_class_entry)->name; + class_name = CG(active_class_entry)->namespaced_name.name; ZEND_ASSERT(class_name && "must know class name when resolving self type at compile time"); } } else { ZEND_ASSERT(fetch_type == ZEND_FETCH_CLASS_PARENT); /* Scope might be unknown for unbound closures and traits */ if (zend_is_scope_known()) { - class_name = CG(active_class_entry)->parent_name; + class_name = CG(active_class_entry)->parent_name->name; ZEND_ASSERT(class_name && "must know class name when resolving parent type at compile time"); } } @@ -7316,6 +7450,9 @@ static zend_type zend_compile_typename_ex( ZEND_TYPE_FULL_MASK(type) |= _ZEND_TYPE_INTERSECTION_BIT; ZEND_TYPE_FULL_MASK(type) |= _ZEND_TYPE_ARENA_BIT; } + } else if (ast->kind == ZEND_AST_INNER_CLASS) { + zend_string *name = zend_resolve_nested_class_name(ast); + return (zend_type) ZEND_TYPE_INIT_CLASS(name, /* allow null */ false, 0); } else { type = zend_compile_single_typename(ast); } @@ -7778,13 +7915,13 @@ static void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32 } if (zend_hash_exists(&scope->properties_info, name)) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", - ZSTR_VAL(scope->name), ZSTR_VAL(name)); + ZSTR_VAL(scope->namespaced_name.name), ZSTR_VAL(name)); } if (ZEND_TYPE_FULL_MASK(arg_info->type) & MAY_BE_CALLABLE) { zend_string *str = zend_type_to_string(arg_info->type); zend_error_noreturn(E_COMPILE_ERROR, "Property %s::$%s cannot have type %s", - ZSTR_VAL(scope->name), ZSTR_VAL(name), ZSTR_VAL(str)); + ZSTR_VAL(scope->namespaced_name.name), ZSTR_VAL(name), ZSTR_VAL(str)); } if (!(property_flags & ZEND_ACC_READONLY) && (scope->ce_flags & ZEND_ACC_READONLY_CLASS)) { @@ -7809,7 +7946,7 @@ static void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32 } else { if (property_flags & ZEND_ACC_READONLY) { zend_error_noreturn(E_COMPILE_ERROR, "Readonly property %s::$%s must have type", - ZSTR_VAL(scope->name), ZSTR_VAL(name)); + ZSTR_VAL(scope->namespaced_name.name), ZSTR_VAL(name)); } ZVAL_NULL(&default_value); @@ -8060,7 +8197,7 @@ static void zend_compile_implicit_closure_uses(closure_info *info) static void add_stringable_interface(zend_class_entry *ce) { for (uint32_t i = 0; i < ce->num_interfaces; i++) { - if (zend_string_equals_literal(ce->interface_names[i].lc_name, "stringable")) { + if (zend_string_equals_literal(ce->interface_names[i].resolved_name, "stringable")) { /* Interface already explicitly implemented */ return; } @@ -8072,7 +8209,7 @@ static void add_stringable_interface(zend_class_entry *ce) { // TODO: Add known interned strings instead? ce->interface_names[ce->num_interfaces - 1].name = ZSTR_INIT_LITERAL("Stringable", 0); - ce->interface_names[ce->num_interfaces - 1].lc_name = + ce->interface_names[ce->num_interfaces - 1].resolved_name = ZSTR_INIT_LITERAL("stringable", 0); } @@ -8101,21 +8238,21 @@ static zend_string *zend_begin_method_decl(zend_op_array *op_array, zend_string ZSTR_VAL(name)); } else if (ce->ce_flags & (ZEND_ACC_ENUM|ZEND_ACC_INTERFACE)) { zend_error_noreturn(E_COMPILE_ERROR, "%s method %s::%s() must not be abstract", - zend_get_object_type_case(ce, true), ZSTR_VAL(ce->name), ZSTR_VAL(name)); + zend_get_object_type_case(ce, true), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } else { zend_error_noreturn(E_COMPILE_ERROR, "Class %s declares abstract method %s() and must therefore be declared abstract", - ZSTR_VAL(ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } } if (in_interface) { if (!(fn_flags & ZEND_ACC_PUBLIC)) { zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method " - "%s::%s() must be public", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + "%s::%s() must be public", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } if (fn_flags & ZEND_ACC_FINAL) { zend_error_noreturn(E_COMPILE_ERROR, "Interface method " - "%s::%s() must not be final", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + "%s::%s() must not be final", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } op_array->fn_flags |= ZEND_ACC_ABSTRACT; } @@ -8123,18 +8260,18 @@ static zend_string *zend_begin_method_decl(zend_op_array *op_array, zend_string if (op_array->fn_flags & ZEND_ACC_ABSTRACT) { if ((op_array->fn_flags & ZEND_ACC_PRIVATE) && !(ce->ce_flags & ZEND_ACC_TRAIT)) { zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", - in_interface ? "Interface" : "Abstract", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + in_interface ? "Interface" : "Abstract", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } if (has_body) { zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", - in_interface ? "Interface" : "Abstract", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + in_interface ? "Interface" : "Abstract", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS; } else if (!has_body) { zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", - ZSTR_VAL(ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } op_array->scope = ce; @@ -8145,7 +8282,7 @@ static zend_string *zend_begin_method_decl(zend_op_array *op_array, zend_string if (zend_hash_add_ptr(&ce->function_table, lcname, op_array) == NULL) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", - ZSTR_VAL(ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } zend_add_magic_method(ce, (zend_function *) op_array, lcname); @@ -8197,8 +8334,8 @@ static zend_string *zend_begin_func_decl(znode *result, zend_op_array *op_array, function = CG(active_op_array)->function_name; parens = "()"; - if (CG(active_class_entry) && CG(active_class_entry)->name) { - class = CG(active_class_entry)->name; + if (CG(active_class_entry) && CG(active_class_entry)->namespaced_name.name) { + class = CG(active_class_entry)->namespaced_name.name; separator = ZSTR_KNOWN(ZEND_STR_PAAMAYIM_NEKUDOTAYIM); } } @@ -8515,7 +8652,7 @@ static void zend_compile_property_hooks( if (hook_kind == (zend_property_hook_kind)-1) { zend_error_noreturn(E_COMPILE_ERROR, "Unknown hook \"%s\" for property %s::$%s, expected \"get\" or \"set\"", - ZSTR_VAL(name), ZSTR_VAL(ce->name), ZSTR_VAL(prop_name)); + ZSTR_VAL(name), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(prop_name)); } if (stmt_ast && stmt_ast->kind == ZEND_AST_PROPERTY_HOOK_SHORT_BODY) { @@ -8537,7 +8674,7 @@ static void zend_compile_property_hooks( if (hook_kind == ZEND_PROPERTY_HOOK_GET) { if (hook->child[0]) { zend_error_noreturn(E_COMPILE_ERROR, "get hook of property %s::$%s must not have a parameter list", - ZSTR_VAL(ce->name), ZSTR_VAL(prop_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(prop_name)); } hook->child[0] = zend_ast_create_list(0, ZEND_AST_PARAM_LIST); @@ -8549,23 +8686,23 @@ static void zend_compile_property_hooks( zend_ast_list *param_list = zend_ast_get_list(hook->child[0]); if (param_list->children != 1) { zend_error_noreturn(E_COMPILE_ERROR, "%s hook of property %s::$%s must accept exactly one parameters", - ZSTR_VAL(name), ZSTR_VAL(ce->name), ZSTR_VAL(prop_name)); + ZSTR_VAL(name), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(prop_name)); } zend_ast *value_param_ast = param_list->child[0]; if (value_param_ast->attr & ZEND_PARAM_REF) { zend_error_noreturn(E_COMPILE_ERROR, "Parameter $%s of %s hook %s::$%s must not be pass-by-reference", - ZSTR_VAL(zend_ast_get_str(value_param_ast->child[1])), ZSTR_VAL(name), ZSTR_VAL(ce->name), ZSTR_VAL(prop_name)); + ZSTR_VAL(zend_ast_get_str(value_param_ast->child[1])), ZSTR_VAL(name), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(prop_name)); } if (value_param_ast->attr & ZEND_PARAM_VARIADIC) { zend_error_noreturn(E_COMPILE_ERROR, "Parameter $%s of %s hook %s::$%s must not be variadic", - ZSTR_VAL(zend_ast_get_str(value_param_ast->child[1])), ZSTR_VAL(name), ZSTR_VAL(ce->name), ZSTR_VAL(prop_name)); + ZSTR_VAL(zend_ast_get_str(value_param_ast->child[1])), ZSTR_VAL(name), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(prop_name)); } if (value_param_ast->child[2]) { zend_error_noreturn(E_COMPILE_ERROR, "Parameter $%s of %s hook %s::$%s must not have a default value", - ZSTR_VAL(zend_ast_get_str(value_param_ast->child[1])), ZSTR_VAL(name), ZSTR_VAL(ce->name), ZSTR_VAL(prop_name)); + ZSTR_VAL(zend_ast_get_str(value_param_ast->child[1])), ZSTR_VAL(name), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(prop_name)); } if ((prop_type_ast != NULL) != (value_param_ast->child[0] != NULL)) { - zend_hooked_property_variance_error_ex(zend_ast_get_str(value_param_ast->child[1]), ce->name, prop_info->name); + zend_hooked_property_variance_error_ex(zend_ast_get_str(value_param_ast->child[1]), ce->namespaced_name.name, prop_info->name); } } else { zend_ast *param_name_ast = zend_ast_create_zval_from_str(ZSTR_KNOWN(ZEND_STR_VALUE)); @@ -8647,7 +8784,7 @@ static void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t f uint32_t i, children = list->children; if (ce->ce_flags & ZEND_ACC_ENUM) { - zend_error_noreturn(E_COMPILE_ERROR, "Enum %s cannot include properties", ZSTR_VAL(ce->name)); + zend_error_noreturn(E_COMPILE_ERROR, "Enum %s cannot include properties", ZSTR_VAL(ce->namespaced_name.name)); } if ((flags & ZEND_ACC_FINAL) && (flags & ZEND_ACC_PRIVATE)) { @@ -8710,7 +8847,7 @@ static void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t f zend_string *str = zend_type_to_string(type); zend_error_noreturn(E_COMPILE_ERROR, "Property %s::$%s cannot have type %s", - ZSTR_VAL(ce->name), ZSTR_VAL(name), ZSTR_VAL(str)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name), ZSTR_VAL(str)); } } @@ -8721,7 +8858,7 @@ static void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t f if (zend_hash_exists(&ce->properties_info, name)) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", - ZSTR_VAL(ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } if (*value_ast_ptr) { @@ -8742,7 +8879,7 @@ static void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t f zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as default value for property %s::$%s of type %s", zend_zval_value_name(&value_zv), - ZSTR_VAL(ce->name), ZSTR_VAL(name), ZSTR_VAL(str)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name), ZSTR_VAL(str)); } } } else if (!ZEND_TYPE_IS_SET(type) && !hooks_ast) { @@ -8758,17 +8895,17 @@ static void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t f if (flags & ZEND_ACC_READONLY) { if (!ZEND_TYPE_IS_SET(type)) { zend_error_noreturn(E_COMPILE_ERROR, "Readonly property %s::$%s must have type", - ZSTR_VAL(ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } if (!Z_ISUNDEF(value_zv)) { zend_error_noreturn(E_COMPILE_ERROR, "Readonly property %s::$%s cannot have default value", - ZSTR_VAL(ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } if (flags & ZEND_ACC_STATIC) { zend_error_noreturn(E_COMPILE_ERROR, "Static property %s::$%s cannot be readonly", - ZSTR_VAL(ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } } @@ -8833,14 +8970,14 @@ static void zend_compile_class_const_decl(zend_ast *ast, uint32_t flags, zend_as zend_string *type_str = zend_type_to_string(type); zend_error_noreturn(E_COMPILE_ERROR, "Class constant %s::%s cannot have type %s", - ZSTR_VAL(ce->name), ZSTR_VAL(name), ZSTR_VAL(type_str)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name), ZSTR_VAL(type_str)); } } if (UNEXPECTED((flags & ZEND_ACC_PRIVATE) && (flags & ZEND_ACC_FINAL))) { zend_error_noreturn( E_COMPILE_ERROR, "Private constant %s::%s cannot be final as it is not visible to other classes", - ZSTR_VAL(ce->name), ZSTR_VAL(name) + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name) ); } @@ -8850,7 +8987,7 @@ static void zend_compile_class_const_decl(zend_ast *ast, uint32_t flags, zend_as zend_string *type_str = zend_type_to_string(type); zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as value for class constant %s::%s of type %s", - zend_zval_type_name(&value_zv), ZSTR_VAL(ce->name), ZSTR_VAL(name), ZSTR_VAL(type_str)); + zend_zval_type_name(&value_zv), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name), ZSTR_VAL(type_str)); } c = zend_declare_typed_class_constant(ce, name, &value_zv, flags, doc_comment, type); @@ -8952,12 +9089,12 @@ static void zend_compile_use_trait(zend_ast *ast) /* {{{ */ if (ce->ce_flags & ZEND_ACC_INTERFACE) { zend_string *name = zend_ast_get_str(trait_ast); zend_error_noreturn(E_COMPILE_ERROR, "Cannot use traits inside of interfaces. " - "%s is used in %s", ZSTR_VAL(name), ZSTR_VAL(ce->name)); + "%s is used in %s", ZSTR_VAL(name), ZSTR_VAL(ce->namespaced_name.name)); } ce->trait_names[ce->num_traits].name = zend_resolve_const_class_name_reference(trait_ast, "trait name"); - ce->trait_names[ce->num_traits].lc_name = zend_string_tolower(ce->trait_names[ce->num_traits].name); + ce->trait_names[ce->num_traits].resolved_name = zend_string_tolower(ce->trait_names[ce->num_traits].name); ce->num_traits++; } @@ -8980,20 +9117,19 @@ static void zend_compile_use_trait(zend_ast *ast) /* {{{ */ } /* }}} */ -static void zend_compile_implements(zend_ast *ast) /* {{{ */ +static void zend_compile_implements(zend_ast *ast, zend_class_entry *ce) /* {{{ */ { zend_ast_list *list = zend_ast_get_list(ast); - zend_class_entry *ce = CG(active_class_entry); - zend_class_name *interface_names; + zend_namespaced_name *interface_names; uint32_t i; - interface_names = emalloc(sizeof(zend_class_name) * list->children); + interface_names = emalloc(sizeof(zend_namespaced_name) * list->children); for (i = 0; i < list->children; ++i) { zend_ast *class_ast = list->child[i]; interface_names[i].name = zend_resolve_const_class_name_reference(class_ast, "interface name"); - interface_names[i].lc_name = zend_string_tolower(interface_names[i].name); + interface_names[i].resolved_name = zend_string_tolower(interface_names[i].name); } ce->num_interfaces = list->children; @@ -9041,6 +9177,24 @@ static void zend_compile_enum_backing_type(zend_class_entry *ce, zend_ast *enum_ zend_type_release(type, 0); } +HashTable *inner_class_queue = NULL; + +static void zend_defer_class_decl(zend_ast *ast) +{ + ZEND_ASSERT(CG(active_class_entry)); + + if (CG(active_op_array)->function_name) { + zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be declared inside functions"); + } + + if (inner_class_queue == NULL) { + ALLOC_HASHTABLE(inner_class_queue); + zend_hash_init(inner_class_queue, 0, NULL, ZVAL_PTR_DTOR, 0); + } + + zend_hash_next_index_insert_ptr(inner_class_queue, ast); +} + static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) /* {{{ */ { zend_ast_decl *decl = (zend_ast_decl *) ast; @@ -9057,10 +9211,6 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) if (EXPECTED((decl->flags & ZEND_ACC_ANON_CLASS) == 0)) { zend_string *unqualified_name = decl->name; - if (CG(active_class_entry)) { - zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested"); - } - const char *type = "a class name"; if (decl->flags & ZEND_ACC_ENUM) { type = "an enum name"; @@ -9070,7 +9220,51 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) type = "a trait name"; } zend_assert_valid_class_name(unqualified_name, type); - name = zend_prefix_with_ns(unqualified_name); + + if (CG(active_class_entry) && CG(active_op_array)->function_name) { + zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be declared inside functions"); + } + + if (CG(active_class_entry)) { + // rename the inner class so we may reference it by name + name = zend_string_concat3( + ZSTR_VAL(CG(active_class_entry)->namespaced_name.name), ZSTR_LEN(CG(active_class_entry)->namespaced_name.name), + "\\", 1, + ZSTR_VAL(unqualified_name), ZSTR_LEN(unqualified_name) + ); + + // configure the current ce->flags for a nested class. This should only include: + // - final + // - readonly + // - abstract + decl->flags |= decl->attr & ZEND_ACC_FINAL; + if (decl->attr & ZEND_ACC_ABSTRACT) { + decl->flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; + } + if (decl->attr & ZEND_ACC_READONLY) { + decl->flags |= ZEND_ACC_READONLY_CLASS | ZEND_ACC_NO_DYNAMIC_PROPERTIES; + } + + // configure for a nested class. This should only include: + // - public + // - private + // - protected + int propFlags = decl->attr & (ZEND_ACC_PUBLIC|ZEND_ACC_PROTECTED|ZEND_ACC_PRIVATE); + // remove the flags from attrs + decl->attr &= ~(ZEND_ACC_PUBLIC|ZEND_ACC_PROTECTED|ZEND_ACC_PRIVATE|ZEND_ACC_FINAL|ZEND_ACC_ABSTRACT|ZEND_ACC_READONLY); + + // if a class is private or protected, we need to require the correct scope + ce->required_scope = propFlags & (ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED) ? CG(active_class_entry) : NULL; + ce->required_scope_absolute = propFlags & ZEND_ACC_PRIVATE ? true : false; + ce->lexical_scope = CG(active_class_entry); + + // ensure the class is treated as a top-level class and not an anon class + toplevel = true; + } else { + name = zend_prefix_with_ns(unqualified_name); + ce->required_scope = NULL; + ce->lexical_scope = NULL; + } name = zend_new_interned_string(name); lcname = zend_string_tolower(name); @@ -9088,6 +9282,8 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) /* Find an anon class name that is not in use yet. */ name = NULL; lcname = NULL; + ce->required_scope = NULL; + ce->lexical_scope = NULL; do { zend_tmp_string_release(name); zend_tmp_string_release(lcname); @@ -9098,10 +9294,10 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) lcname = zend_new_interned_string(lcname); ce->type = ZEND_USER_CLASS; - ce->name = name; + ce->namespaced_name.name = name; zend_initialize_class_data(ce, 1); if (!(decl->flags & ZEND_ACC_ANON_CLASS)) { - zend_alloc_ce_cache(ce->name); + zend_alloc_ce_cache(ce->namespaced_name.name); } if (CG(compiler_options) & ZEND_COMPILE_PRELOAD) { @@ -9129,16 +9325,16 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) zend_resolve_const_class_name_reference(extends_ast, "class name"); } + if (implements_ast) { + zend_compile_implements(implements_ast, ce); + } + CG(active_class_entry) = ce; if (decl->child[3]) { zend_compile_attributes(&ce->attributes, decl->child[3], 0, ZEND_ATTRIBUTE_TARGET_CLASS, 0); } - if (implements_ast) { - zend_compile_implements(implements_ast); - } - if (ce->ce_flags & ZEND_ACC_ENUM) { if (enum_backing_type_ast != NULL) { zend_compile_enum_backing_type(ce, enum_backing_type_ast); @@ -9156,8 +9352,6 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) zend_verify_abstract_class(ce); } - CG(active_class_entry) = original_ce; - if (toplevel) { ce->ce_flags |= ZEND_ACC_TOP_LEVEL; } @@ -9172,13 +9366,13 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) if (toplevel) { if (extends_ast) { zend_class_entry *parent_ce = zend_lookup_class_ex( - ce->parent_name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD); + ce->parent_name->name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD); if (parent_ce && !zend_compile_ignore_class(parent_ce, ce->info.user.filename)) { if (zend_try_early_bind(ce, parent_ce, lcname, NULL)) { zend_string_release(lcname); - return; + goto compile_inner_classes; } } } else if (EXPECTED(zend_hash_add_ptr(CG(class_table), lcname, ce) != NULL)) { @@ -9187,7 +9381,7 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) zend_inheritance_check_override(ce); ce->ce_flags |= ZEND_ACC_LINKED; zend_observer_class_linked_notify(ce, lcname); - return; + goto compile_inner_classes; } else { goto link_unbound; } @@ -9204,7 +9398,7 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) if (ce->parent_name) { /* Lowercased parent name */ - zend_string *lc_parent_name = zend_string_tolower(ce->parent_name); + zend_string *lc_parent_name = zend_string_tolower(ce->parent_name->name); opline->op2_type = IS_CONST; LITERAL_STR(opline->op2, lc_parent_name); } @@ -9257,6 +9451,25 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) opline->result.opline_num = -1; } } + + compile_inner_classes: + + if (inner_class_queue == NULL) { + CG(active_class_entry) = original_ce; + return; + } + + HashTable *queue = inner_class_queue; + inner_class_queue = NULL; + + ZEND_HASH_FOREACH_PTR(queue, ast) { + zend_compile_class_decl(NULL, ast, 0); + } ZEND_HASH_FOREACH_END(); + + CG(active_class_entry) = original_ce; + + zend_hash_destroy(queue); + FREE_HASHTABLE(queue); } /* }}} */ @@ -9268,7 +9481,7 @@ static void zend_compile_enum_case(zend_ast *ast) } zend_string *enum_case_name = zval_make_interned_string(zend_ast_get_zval(ast->child[0])); - zend_string *enum_class_name = enum_class->name; + zend_string *enum_class_name = enum_class->namespaced_name.name; zval class_name_zval; ZVAL_STR_COPY(&class_name_zval, enum_class_name); @@ -9655,7 +9868,7 @@ static bool zend_try_ct_eval_magic_const(zval *zv, zend_ast *ast) /* {{{ */ if (op_array && op_array->function_name) { if (op_array->scope) { ZVAL_NEW_STR(zv, - zend_create_member_string(op_array->scope->name, op_array->function_name)); + zend_create_member_string(op_array->scope->namespaced_name.name, op_array->function_name)); } else { ZVAL_STR_COPY(zv, op_array->function_name); } @@ -9668,7 +9881,7 @@ static bool zend_try_ct_eval_magic_const(zval *zv, zend_ast *ast) /* {{{ */ if ((ce->ce_flags & ZEND_ACC_TRAIT) != 0) { return 0; } else { - ZVAL_STR_COPY(zv, ce->name); + ZVAL_STR_COPY(zv, ce->namespaced_name.name); } } else { ZVAL_EMPTY_STRING(zv); @@ -9676,7 +9889,7 @@ static bool zend_try_ct_eval_magic_const(zval *zv, zend_ast *ast) /* {{{ */ break; case T_TRAIT_C: if (ce && (ce->ce_flags & ZEND_ACC_TRAIT) != 0) { - ZVAL_STR_COPY(zv, ce->name); + ZVAL_STR_COPY(zv, ce->namespaced_name.name); } else { ZVAL_EMPTY_STRING(zv); } @@ -11527,6 +11740,10 @@ static void zend_compile_stmt(zend_ast *ast) /* {{{ */ zend_compile_use_trait(ast); break; case ZEND_AST_CLASS: + if (CG(active_class_entry)) { + zend_defer_class_decl(ast); + break; + } zend_compile_class_decl(NULL, ast, 0); break; case ZEND_AST_GROUP_USE: @@ -11697,6 +11914,9 @@ static void zend_compile_expr_inner(znode *result, zend_ast *ast) /* {{{ */ case ZEND_AST_MATCH: zend_compile_match(result, ast); return; + case ZEND_AST_INNER_CLASS: + zend_compile_inner_class_ref(result, ast, ZEND_FETCH_CLASS_EXCEPTION); + return; default: ZEND_ASSERT(0 /* not supported */); } diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index a7ee8f9327c54..f2b8b7db27b9f 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -583,7 +583,7 @@ typedef struct _zend_internal_function { void *reserved[ZEND_MAX_RESERVED_RESOURCES]; } zend_internal_function; -#define ZEND_FN_SCOPE_NAME(function) ((function) && (function)->common.scope ? ZSTR_VAL((function)->common.scope->name) : "") +#define ZEND_FN_SCOPE_NAME(function) ((function) && (function)->common.scope ? ZSTR_VAL((function)->common.scope->namespaced_name.name) : "") union _zend_function { uint8_t type; /* MUST be the first element of this struct! */ @@ -894,6 +894,7 @@ typedef enum { ZEND_MODIFIER_TARGET_CONSTANT, ZEND_MODIFIER_TARGET_CPP, ZEND_MODIFIER_TARGET_PROPERTY_HOOK, + ZEND_MODIFIER_TARGET_INNER_CLASS, } zend_modifier_target; /* Used during AST construction */ @@ -1020,20 +1021,22 @@ ZEND_API zend_string *zend_type_to_string(zend_type type); #define ZEND_FETCH_CLASS_AUTO 4 #define ZEND_FETCH_CLASS_INTERFACE 5 #define ZEND_FETCH_CLASS_TRAIT 6 +#define ZEND_FETCH_CLASS_OUTER 7 #define ZEND_FETCH_CLASS_MASK 0x0f #define ZEND_FETCH_CLASS_NO_AUTOLOAD 0x80 #define ZEND_FETCH_CLASS_SILENT 0x0100 #define ZEND_FETCH_CLASS_EXCEPTION 0x0200 #define ZEND_FETCH_CLASS_ALLOW_UNLINKED 0x0400 #define ZEND_FETCH_CLASS_ALLOW_NEARLY_LINKED 0x0800 +#define ZEND_FETCH_CLASS_NO_INNER 0x1000 /* These should not clash with ZEND_ACC_PPP_MASK and ZEND_ACC_PPP_SET_MASK */ #define ZEND_PARAM_REF (1<<3) #define ZEND_PARAM_VARIADIC (1<<4) -#define ZEND_NAME_FQ 0 -#define ZEND_NAME_NOT_FQ 1 -#define ZEND_NAME_RELATIVE 2 +#define ZEND_NAME_FQ 0 +#define ZEND_NAME_NOT_FQ 1 +#define ZEND_NAME_RELATIVE 2 /* ZEND_FETCH_ flags in class name AST of new const expression must not clash with ZEND_NAME_ flags */ #define ZEND_CONST_EXPR_NEW_FETCH_TYPE_SHIFT 2 diff --git a/Zend/zend_enum.c b/Zend/zend_enum.c index ccafca48fe9b8..688445385e947 100644 --- a/Zend/zend_enum.c +++ b/Zend/zend_enum.c @@ -28,7 +28,7 @@ #define ZEND_ENUM_DISALLOW_MAGIC_METHOD(propertyName, methodName) \ do { \ if (ce->propertyName) { \ - zend_error_noreturn(E_COMPILE_ERROR, "Enum %s cannot include magic method %s", ZSTR_VAL(ce->name), methodName); \ + zend_error_noreturn(E_COMPILE_ERROR, "Enum %s cannot include magic method %s", ZSTR_VAL(ce->namespaced_name.name), methodName); \ } \ } while (0); @@ -73,7 +73,7 @@ static void zend_verify_enum_properties(const zend_class_entry *ce) } // FIXME: File/line number for traits? zend_error_noreturn(E_COMPILE_ERROR, "Enum %s cannot include properties", - ZSTR_VAL(ce->name)); + ZSTR_VAL(ce->namespaced_name.name)); } ZEND_HASH_FOREACH_END(); } @@ -104,7 +104,7 @@ static void zend_verify_enum_magic_methods(const zend_class_entry *ce) const char *forbidden_method = forbidden_methods[i]; if (zend_hash_str_exists(&ce->function_table, forbidden_method, strlen(forbidden_method))) { - zend_error_noreturn(E_COMPILE_ERROR, "Enum %s cannot include magic method %s", ZSTR_VAL(ce->name), forbidden_method); + zend_error_noreturn(E_COMPILE_ERROR, "Enum %s cannot include magic method %s", ZSTR_VAL(ce->namespaced_name.name), forbidden_method); } } } @@ -113,7 +113,7 @@ static void zend_verify_enum_interfaces(const zend_class_entry *ce) { if (zend_class_implements_interface(ce, zend_ce_serializable)) { zend_error_noreturn(E_COMPILE_ERROR, - "Enum %s cannot implement the Serializable interface", ZSTR_VAL(ce->name)); + "Enum %s cannot implement the Serializable interface", ZSTR_VAL(ce->namespaced_name.name)); } } @@ -131,8 +131,8 @@ static int zend_implement_unit_enum(zend_class_entry *interface, zend_class_entr } zend_error_noreturn(E_ERROR, "Non-enum class %s cannot implement interface %s", - ZSTR_VAL(class_type->name), - ZSTR_VAL(interface->name)); + ZSTR_VAL(class_type->namespaced_name.name), + ZSTR_VAL(interface->namespaced_name.name)); return FAILURE; } @@ -141,15 +141,15 @@ static int zend_implement_backed_enum(zend_class_entry *interface, zend_class_en { if (!(class_type->ce_flags & ZEND_ACC_ENUM)) { zend_error_noreturn(E_ERROR, "Non-enum class %s cannot implement interface %s", - ZSTR_VAL(class_type->name), - ZSTR_VAL(interface->name)); + ZSTR_VAL(class_type->namespaced_name.name), + ZSTR_VAL(interface->namespaced_name.name)); return FAILURE; } if (class_type->enum_backing_type == IS_UNDEF) { zend_error_noreturn(E_ERROR, "Non-backed enum %s cannot implement interface %s", - ZSTR_VAL(class_type->name), - ZSTR_VAL(interface->name)); + ZSTR_VAL(class_type->namespaced_name.name), + ZSTR_VAL(interface->namespaced_name.name)); return FAILURE; } @@ -182,12 +182,12 @@ void zend_enum_add_interfaces(zend_class_entry *ce) ce->interface_names = erealloc(ce->interface_names, sizeof(zend_class_name) * ce->num_interfaces); - ce->interface_names[num_interfaces_before].name = zend_string_copy(zend_ce_unit_enum->name); - ce->interface_names[num_interfaces_before].lc_name = ZSTR_INIT_LITERAL("unitenum", 0); + ce->interface_names[num_interfaces_before].name = zend_string_copy(zend_ce_unit_enum->namespaced_name.name); + ce->interface_names[num_interfaces_before].resolved_name = ZSTR_INIT_LITERAL("unitenum", 0); if (ce->enum_backing_type != IS_UNDEF) { - ce->interface_names[num_interfaces_before + 1].name = zend_string_copy(zend_ce_backed_enum->name); - ce->interface_names[num_interfaces_before + 1].lc_name = ZSTR_INIT_LITERAL("backedenum", 0); + ce->interface_names[num_interfaces_before + 1].name = zend_string_copy(zend_ce_backed_enum->namespaced_name.name); + ce->interface_names[num_interfaces_before + 1].resolved_name = ZSTR_INIT_LITERAL("backedenum", 0); } ce->default_object_handlers = &zend_enum_object_handlers; @@ -205,7 +205,7 @@ zend_result zend_enum_build_backed_enum_table(zend_class_entry *ce) zend_hash_init(backed_enum_table, 0, NULL, ZVAL_PTR_DTOR, 0); zend_class_set_backed_enum_table(ce, backed_enum_table); - const zend_string *enum_class_name = ce->name; + const zend_string *enum_class_name = ce->namespaced_name.name; zend_string *name; zval *val; @@ -316,10 +316,10 @@ ZEND_API zend_result zend_enum_get_case_by_value(zend_object **result, zend_clas } if (ce->enum_backing_type == IS_LONG) { - zend_value_error(ZEND_LONG_FMT " is not a valid backing value for enum %s", long_key, ZSTR_VAL(ce->name)); + zend_value_error(ZEND_LONG_FMT " is not a valid backing value for enum %s", long_key, ZSTR_VAL(ce->namespaced_name.name)); } else { ZEND_ASSERT(ce->enum_backing_type == IS_STRING); - zend_value_error("\"%s\" is not a valid backing value for enum %s", ZSTR_VAL(string_key), ZSTR_VAL(ce->name)); + zend_value_error("\"%s\" is not a valid backing value for enum %s", ZSTR_VAL(string_key), ZSTR_VAL(ce->namespaced_name.name)); } return FAILURE; } @@ -432,7 +432,7 @@ static void zend_enum_register_func(zend_class_entry *ce, zend_known_string_id n } if (!zend_hash_add_ptr(&ce->function_table, name, zif)) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } } @@ -506,7 +506,9 @@ ZEND_API zend_class_entry *zend_register_internal_enum( ZEND_ASSERT(type == IS_UNDEF || type == IS_LONG || type == IS_STRING); zend_class_entry tmp_ce; - INIT_CLASS_ENTRY_EX(tmp_ce, name, strlen(name), functions); + zend_namespaced_name tmp_name; + INIT_CLASS_NAME(tmp_name, name); + INIT_CLASS_ENTRY_EX(tmp_ce, tmp_name, functions); zend_class_entry *ce = zend_register_internal_class(&tmp_ce); ce->ce_flags |= ZEND_ACC_ENUM; @@ -597,7 +599,7 @@ ZEND_API void zend_enum_add_case(zend_class_entry *ce, zend_string *case_name, z zval ast_zv; Z_TYPE_INFO(ast_zv) = IS_CONSTANT_AST; - Z_AST(ast_zv) = create_enum_case_ast(ce->name, case_name, value); + Z_AST(ast_zv) = create_enum_case_ast(ce->namespaced_name.name, case_name, value); zend_class_constant *c = zend_declare_class_constant_ex( ce, case_name, &ast_zv, ZEND_ACC_PUBLIC, NULL); ZEND_CLASS_CONST_FLAGS(c) |= ZEND_CLASS_CONST_IS_CASE; diff --git a/Zend/zend_enum_arginfo.h b/Zend/zend_enum_arginfo.h index 64c36ff3c33af..73beddc55cb1e 100644 --- a/Zend/zend_enum_arginfo.h +++ b/Zend/zend_enum_arginfo.h @@ -27,8 +27,10 @@ static const zend_function_entry class_BackedEnum_methods[] = { static zend_class_entry *register_class_UnitEnum(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "UnitEnum", class_UnitEnum_methods); + INIT_CLASS_NAME(namespaced_name, "UnitEnum"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_UnitEnum_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -37,8 +39,10 @@ static zend_class_entry *register_class_UnitEnum(void) static zend_class_entry *register_class_BackedEnum(zend_class_entry *class_entry_UnitEnum) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "BackedEnum", class_BackedEnum_methods); + INIT_CLASS_NAME(namespaced_name, "BackedEnum"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_BackedEnum_methods); class_entry = zend_register_internal_interface(&ce); zend_class_implements(class_entry, 1, class_entry_UnitEnum); diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c index f9d0ae8ea8173..4f9a632a8ffd1 100644 --- a/Zend/zend_exceptions.c +++ b/Zend/zend_exceptions.c @@ -63,8 +63,8 @@ static int zend_implement_throwable(zend_class_entry *interface, zend_class_entr while (root->parent) { root = root->parent; } - if (zend_string_equals_literal(root->name, "Exception") - || zend_string_equals_literal(root->name, "Error")) { + if (zend_string_equals_literal(root->namespaced_name.name, "Exception") + || zend_string_equals_literal(root->namespaced_name.name, "Error")) { return SUCCESS; } @@ -75,8 +75,8 @@ static int zend_implement_throwable(zend_class_entry *interface, zend_class_entr ? "%s %s cannot implement interface %s, extend Exception or Error instead" : "%s %s cannot implement interface %s", zend_get_object_type_uc(class_type), - ZSTR_VAL(class_type->name), - ZSTR_VAL(interface->name)); + ZSTR_VAL(class_type->namespaced_name.name), + ZSTR_VAL(interface->namespaced_name.name)); return FAILURE; } /* }}} */ @@ -693,7 +693,7 @@ ZEND_METHOD(Exception, __toString) ? zend_string_copy(Z_STR(trace)) : ZSTR_INIT_LITERAL("#0 {main}\n", false); - zend_string *name = Z_OBJCE_P(exception)->name; + zend_string *name = Z_OBJCE_P(exception)->namespaced_name.name; if (ZSTR_LEN(message) > 0) { zval message_zv; @@ -796,9 +796,13 @@ void zend_register_default_exception(void) /* {{{ */ zend_ce_request_parse_body_exception = register_class_RequestParseBodyException(zend_ce_exception); zend_init_exception_class_entry(zend_ce_request_parse_body_exception); - INIT_CLASS_ENTRY(zend_ce_unwind_exit, "UnwindExit", NULL); + zend_namespaced_name unwind_exit_name; + INIT_CLASS_NAME(unwind_exit_name, "UnwindExit"); + INIT_CLASS_ENTRY(zend_ce_unwind_exit, unwind_exit_name, NULL); - INIT_CLASS_ENTRY(zend_ce_graceful_exit, "GracefulExit", NULL); + zend_namespaced_name graceful_exit_name; + INIT_CLASS_NAME(graceful_exit_name, "GracefulExit"); + INIT_CLASS_ENTRY(zend_ce_graceful_exit, graceful_exit_name, NULL); } /* }}} */ @@ -926,7 +930,7 @@ ZEND_API ZEND_COLD zend_result zend_exception_error(zend_object *ex, int severit zend_call_known_instance_method_with_0_params(ex->ce->__tostring, ex, &tmp); if (!EG(exception)) { if (Z_TYPE(tmp) != IS_STRING) { - zend_error(E_WARNING, "%s::__toString() must return a string", ZSTR_VAL(ce_exception->name)); + zend_error(E_WARNING, "%s::__toString() must return a string", ZSTR_VAL(ce_exception->namespaced_name.name)); } else { zend_update_property_ex(i_get_exception_base(ex), ex, ZSTR_KNOWN(ZEND_STR_STRING), &tmp); } @@ -945,7 +949,7 @@ ZEND_API ZEND_COLD zend_result zend_exception_error(zend_object *ex, int severit zend_error_va(E_WARNING, (file && ZSTR_LEN(file) > 0) ? file : NULL, line, "Uncaught %s in exception handling during call to %s::__toString()", - ZSTR_VAL(Z_OBJCE(zv)->name), ZSTR_VAL(ce_exception->name)); + ZSTR_VAL(Z_OBJCE(zv)->namespaced_name.name), ZSTR_VAL(ce_exception->namespaced_name.name)); if (file) { zend_string_release_ex(file, 0); @@ -966,7 +970,7 @@ ZEND_API ZEND_COLD zend_result zend_exception_error(zend_object *ex, int severit /* We successfully unwound, nothing more to do. * We still return FAILURE in this case, as further execution should still be aborted. */ } else { - zend_error(severity, "Uncaught exception %s", ZSTR_VAL(ce_exception->name)); + zend_error(severity, "Uncaught exception %s", ZSTR_VAL(ce_exception->namespaced_name.name)); } OBJ_RELEASE(ex); diff --git a/Zend/zend_exceptions_arginfo.h b/Zend/zend_exceptions_arginfo.h index cef37a1f0f0b9..e37085c831854 100644 --- a/Zend/zend_exceptions_arginfo.h +++ b/Zend/zend_exceptions_arginfo.h @@ -145,8 +145,10 @@ static const zend_function_entry class_Error_methods[] = { static zend_class_entry *register_class_Throwable(zend_class_entry *class_entry_Stringable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Throwable", class_Throwable_methods); + INIT_CLASS_NAME(namespaced_name, "Throwable"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Throwable_methods); class_entry = zend_register_internal_interface(&ce); zend_class_implements(class_entry, 1, class_entry_Stringable); @@ -156,8 +158,10 @@ static zend_class_entry *register_class_Throwable(zend_class_entry *class_entry_ static zend_class_entry *register_class_Exception(zend_class_entry *class_entry_Throwable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Exception", class_Exception_methods); + INIT_CLASS_NAME(namespaced_name, "Exception"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Exception_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_Throwable); @@ -196,8 +200,10 @@ static zend_class_entry *register_class_Exception(zend_class_entry *class_entry_ static zend_class_entry *register_class_ErrorException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ErrorException", class_ErrorException_methods); + INIT_CLASS_NAME(namespaced_name, "ErrorException"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ErrorException_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, 0); zval property_severity_default_value; @@ -210,8 +216,10 @@ static zend_class_entry *register_class_ErrorException(zend_class_entry *class_e static zend_class_entry *register_class_Error(zend_class_entry *class_entry_Throwable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Error", class_Error_methods); + INIT_CLASS_NAME(namespaced_name, "Error"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Error_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_Throwable); @@ -250,8 +258,10 @@ static zend_class_entry *register_class_Error(zend_class_entry *class_entry_Thro static zend_class_entry *register_class_CompileError(zend_class_entry *class_entry_Error) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "CompileError", NULL); + INIT_CLASS_NAME(namespaced_name, "CompileError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Error, 0); return class_entry; @@ -260,8 +270,10 @@ static zend_class_entry *register_class_CompileError(zend_class_entry *class_ent static zend_class_entry *register_class_ParseError(zend_class_entry *class_entry_CompileError) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ParseError", NULL); + INIT_CLASS_NAME(namespaced_name, "ParseError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_CompileError, 0); return class_entry; @@ -270,8 +282,10 @@ static zend_class_entry *register_class_ParseError(zend_class_entry *class_entry static zend_class_entry *register_class_TypeError(zend_class_entry *class_entry_Error) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "TypeError", NULL); + INIT_CLASS_NAME(namespaced_name, "TypeError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Error, 0); return class_entry; @@ -280,8 +294,10 @@ static zend_class_entry *register_class_TypeError(zend_class_entry *class_entry_ static zend_class_entry *register_class_ArgumentCountError(zend_class_entry *class_entry_TypeError) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ArgumentCountError", NULL); + INIT_CLASS_NAME(namespaced_name, "ArgumentCountError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_TypeError, 0); return class_entry; @@ -290,8 +306,10 @@ static zend_class_entry *register_class_ArgumentCountError(zend_class_entry *cla static zend_class_entry *register_class_ValueError(zend_class_entry *class_entry_Error) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ValueError", NULL); + INIT_CLASS_NAME(namespaced_name, "ValueError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Error, 0); return class_entry; @@ -300,8 +318,10 @@ static zend_class_entry *register_class_ValueError(zend_class_entry *class_entry static zend_class_entry *register_class_ArithmeticError(zend_class_entry *class_entry_Error) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ArithmeticError", NULL); + INIT_CLASS_NAME(namespaced_name, "ArithmeticError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Error, 0); return class_entry; @@ -310,8 +330,10 @@ static zend_class_entry *register_class_ArithmeticError(zend_class_entry *class_ static zend_class_entry *register_class_DivisionByZeroError(zend_class_entry *class_entry_ArithmeticError) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DivisionByZeroError", NULL); + INIT_CLASS_NAME(namespaced_name, "DivisionByZeroError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ArithmeticError, 0); return class_entry; @@ -320,8 +342,10 @@ static zend_class_entry *register_class_DivisionByZeroError(zend_class_entry *cl static zend_class_entry *register_class_UnhandledMatchError(zend_class_entry *class_entry_Error) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "UnhandledMatchError", NULL); + INIT_CLASS_NAME(namespaced_name, "UnhandledMatchError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Error, 0); return class_entry; @@ -330,8 +354,10 @@ static zend_class_entry *register_class_UnhandledMatchError(zend_class_entry *cl static zend_class_entry *register_class_RequestParseBodyException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RequestParseBodyException", NULL); + INIT_CLASS_NAME(namespaced_name, "RequestParseBodyException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, 0); return class_entry; diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 6b6af2c225f79..bb0a95a181160 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -613,7 +613,7 @@ static zend_never_inline ZEND_COLD void zend_throw_auto_init_in_prop_error(zend_ zend_string *type_str = zend_type_to_string(prop->type); zend_type_error( "Cannot auto-initialize an array inside property %s::$%s of type %s", - ZSTR_VAL(prop->ce->name), zend_get_unmangled_property_name(prop->name), + ZSTR_VAL(prop->ce->namespaced_name.name), zend_get_unmangled_property_name(prop->name), ZSTR_VAL(type_str) ); zend_string_release(type_str); @@ -623,7 +623,7 @@ static zend_never_inline ZEND_COLD void zend_throw_auto_init_in_ref_error(zend_p zend_string *type_str = zend_type_to_string(prop->type); zend_type_error( "Cannot auto-initialize an array inside a reference held by property %s::$%s of type %s", - ZSTR_VAL(prop->ce->name), zend_get_unmangled_property_name(prop->name), + ZSTR_VAL(prop->ce->namespaced_name.name), zend_get_unmangled_property_name(prop->name), ZSTR_VAL(type_str) ); zend_string_release(type_str); @@ -633,7 +633,7 @@ static zend_never_inline ZEND_COLD void zend_throw_access_uninit_prop_by_ref_err zend_property_info *prop) { zend_throw_error(NULL, "Cannot access uninitialized non-nullable property %s::$%s by reference", - ZSTR_VAL(prop->ce->name), + ZSTR_VAL(prop->ce->namespaced_name.name), zend_get_unmangled_property_name(prop->name)); } @@ -680,7 +680,7 @@ static ZEND_COLD void zend_verify_type_error_common( *fname = ZSTR_VAL(zf->common.function_name); if (zf->common.scope) { *fsep = "::"; - *fclass = ZSTR_VAL(zf->common.scope->name); + *fclass = ZSTR_VAL(zf->common.scope->namespaced_name.name); } else { *fsep = ""; *fclass = ""; @@ -832,7 +832,7 @@ ZEND_COLD zend_never_inline void zend_verify_class_constant_type_error(const zen zend_string *type_str = zend_type_to_string(c->type); zend_type_error("Cannot assign %s to class constant %s::%s of type %s", - zend_zval_type_name(constant), ZSTR_VAL(c->ce->name), ZSTR_VAL(name), ZSTR_VAL(type_str)); + zend_zval_type_name(constant), ZSTR_VAL(c->ce->namespaced_name.name), ZSTR_VAL(name), ZSTR_VAL(type_str)); zend_string_release(type_str); } @@ -849,7 +849,7 @@ ZEND_COLD zend_never_inline void zend_verify_property_type_error(const zend_prop type_str = zend_type_to_string(info->type); zend_type_error("Cannot assign %s to property %s::$%s of type %s", zend_zval_value_name(property), - ZSTR_VAL(info->ce->name), + ZSTR_VAL(info->ce->namespaced_name.name), zend_get_unmangled_property_name(info->name), ZSTR_VAL(type_str)); zend_string_release(type_str); @@ -865,8 +865,8 @@ ZEND_COLD zend_never_inline void zend_magic_get_property_type_inconsistency_erro zend_string *type_str = zend_type_to_string(info->type); zend_type_error("Value of type %s returned from %s::__get() must be compatible with unset property %s::$%s of type %s", zend_zval_type_name(property), - ZSTR_VAL(info->ce->name), - ZSTR_VAL(info->ce->name), + ZSTR_VAL(info->ce->namespaced_name.name), + ZSTR_VAL(info->ce->namespaced_name.name), zend_get_unmangled_property_name(info->name), ZSTR_VAL(type_str)); zend_string_release(type_str); @@ -895,7 +895,7 @@ ZEND_COLD void zend_match_unhandled_error(const zval *value) ZEND_API ZEND_COLD void ZEND_FASTCALL zend_readonly_property_modification_error( const zend_property_info *info) { zend_readonly_property_modification_error_ex( - ZSTR_VAL(info->ce->name), zend_get_unmangled_property_name(info->name)); + ZSTR_VAL(info->ce->namespaced_name.name), zend_get_unmangled_property_name(info->name)); } ZEND_API ZEND_COLD void ZEND_FASTCALL zend_readonly_property_modification_error_ex( @@ -906,7 +906,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_readonly_property_modification_error_ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_readonly_property_indirect_modification_error(const zend_property_info *info) { zend_throw_error(NULL, "Cannot indirectly modify readonly property %s::$%s", - ZSTR_VAL(info->ce->name), zend_get_unmangled_property_name(info->name)); + ZSTR_VAL(info->ce->namespaced_name.name), zend_get_unmangled_property_name(info->name)); } ZEND_API ZEND_COLD void ZEND_FASTCALL zend_invalid_class_constant_type_error(uint8_t type) @@ -917,7 +917,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_invalid_class_constant_type_error(uin ZEND_API ZEND_COLD void ZEND_FASTCALL zend_object_released_while_assigning_to_property_error(const zend_property_info *info) { zend_throw_error(NULL, "Object was released while assigning to property %s::$%s", - ZSTR_VAL(info->ce->name), zend_get_unmangled_property_name(info->name)); + ZSTR_VAL(info->ce->namespaced_name.name), zend_get_unmangled_property_name(info->name)); } ZEND_API ZEND_COLD void ZEND_FASTCALL zend_asymmetric_visibility_property_modification_error( @@ -945,9 +945,9 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_asymmetric_visibility_property_modifi zend_throw_error(NULL, "Cannot %s %s property %s::$%s from %s%s", operation, visibility, - ZSTR_VAL(prop_info->ce->name), + ZSTR_VAL(prop_info->ce->namespaced_name.name), ZSTR_VAL(prop_info->name), - scope ? "scope " : "global scope", scope ? ZSTR_VAL(scope->name) : ""); + scope ? "scope " : "global scope", scope ? ZSTR_VAL(scope->namespaced_name.name) : ""); } static const zend_class_entry *resolve_single_class_type(zend_string *name, const zend_class_entry *self_ce) { @@ -1045,8 +1045,45 @@ static zend_always_inline bool i_zend_check_property_type(const zend_property_in return zend_verify_scalar_type_hint(type_mask, property, strict, 0); } +static zend_always_inline bool zend_check_class_visibility(const zend_class_entry *ce, const zend_property_info *info, uint32_t current_visibility) { + // a public class is always visible + if (!ce->required_scope) { + return 1; + } + + // a protected class is visible if it is a subclass of the lexical scope and the current visibility is protected or private + if (!ce->required_scope_absolute) { + if (current_visibility & ZEND_ACC_PUBLIC) { + zend_type_error("Cannot assign protected %s to higher visibile property %s::%s", + ZSTR_VAL(ce->namespaced_name.name), + ZSTR_VAL(info->ce->namespaced_name.name), + zend_get_unmangled_property_name(info->name)); + return 0; + } + + return 1; + } + + // a private class is visible if it is the same class as the lexical scope and the current visibility is private + if (ce->required_scope_absolute && current_visibility & ZEND_ACC_PRIVATE) { + return 1; + } + + zend_type_error("Cannot assign private %s to higher visibile property %s::%s", + ZSTR_VAL(ce->namespaced_name.name), + ZSTR_VAL(info->ce->namespaced_name.name), + zend_get_unmangled_property_name(info->name)); + + return 0; +} + static zend_always_inline bool i_zend_verify_property_type(const zend_property_info *info, zval *property, bool strict) { + if(Z_TYPE_P(property) == IS_OBJECT && !zend_check_class_visibility(Z_OBJCE_P(property), info, info->flags)) { + zend_verify_property_type_error(info, property); + return 0; + } + if (i_zend_check_property_type(info, property, strict)) { return 1; } @@ -1196,6 +1233,23 @@ static zend_always_inline bool zend_check_type_slow( } } else { ce = zend_fetch_ce_from_cache_slot(cache_slot, type); + + // verify that the class is being used in the correct scope + if (ce && ce->required_scope) { + zend_class_entry *scope = zend_get_executed_scope(); + if (ce->required_scope_absolute && scope != ce->required_scope) { + if (scope == NULL) { + zend_error(E_ERROR, "Private inner class %s cannot be used as a type declaration in the global scope", ZSTR_VAL(ce->namespaced_name.name)); + } + + zend_error(E_ERROR, "Private inner class %s cannot be used as a type declaration in the scope of %s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(scope->namespaced_name.name)); + } else if (scope == NULL) { + zend_error(E_ERROR, "Protected inner class %s cannot be used as a type declaration in the global scope", ZSTR_VAL(ce->namespaced_name.name)); + } else if (!instanceof_function(scope, ce->required_scope)) { + zend_error(E_ERROR, "Protected inner class %s cannot be used as a type declaration in the scope of %s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(scope->namespaced_name.name)); + } + } + /* If we have a CE we check if it satisfies the type constraint, * otherwise it will check if a standard type satisfies it. */ if (ce && instanceof_function(Z_OBJCE_P(arg), ce)) { @@ -1344,7 +1398,7 @@ ZEND_API bool zend_internal_call_should_throw(zend_function *fbc, zend_execute_d ZEND_API ZEND_COLD void zend_internal_call_arginfo_violation(zend_function *fbc) { zend_error_noreturn(E_ERROR, "Arginfo / zpp mismatch during call of %s%s%s()", - fbc->common.scope ? ZSTR_VAL(fbc->common.scope->name) : "", + fbc->common.scope ? ZSTR_VAL(fbc->common.scope->namespaced_name.name) : "", fbc->common.scope ? "::" : "", ZSTR_VAL(fbc->common.function_name)); } @@ -1418,7 +1472,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_missing_arg_error(zend_execute_data * if (ptr && ptr->func && ZEND_USER_CODE(ptr->func->common.type)) { zend_throw_error(zend_ce_argument_count_error, "Too few arguments to function %s%s%s(), %d passed in %s on line %d and %s %d expected", - EX(func)->common.scope ? ZSTR_VAL(EX(func)->common.scope->name) : "", + EX(func)->common.scope ? ZSTR_VAL(EX(func)->common.scope->namespaced_name.name) : "", EX(func)->common.scope ? "::" : "", ZSTR_VAL(EX(func)->common.function_name), EX_NUM_ARGS(), @@ -1428,7 +1482,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_missing_arg_error(zend_execute_data * EX(func)->common.required_num_args); } else { zend_throw_error(zend_ce_argument_count_error, "Too few arguments to function %s%s%s(), %d passed and %s %d expected", - EX(func)->common.scope ? ZSTR_VAL(EX(func)->common.scope->name) : "", + EX(func)->common.scope ? ZSTR_VAL(EX(func)->common.scope->namespaced_name.name) : "", EX(func)->common.scope ? "::" : "", ZSTR_VAL(EX(func)->common.function_name), EX_NUM_ARGS(), @@ -1486,7 +1540,7 @@ static ZEND_COLD void zend_verify_void_return_error(const zend_function *zf, con if (zf->common.scope) { fsep = "::"; - fclass = ZSTR_VAL(zf->common.scope->name); + fclass = ZSTR_VAL(zf->common.scope->namespaced_name.name); } else { fsep = ""; fclass = ""; @@ -1552,7 +1606,7 @@ ZEND_API bool zend_never_inline zend_verify_class_constant_type(zend_class_const static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_use_object_as_array(const zend_object *object) { - zend_throw_error(NULL, "Cannot use object of type %s as array", ZSTR_VAL(object->ce->name)); + zend_throw_error(NULL, "Cannot use object of type %s as array", ZSTR_VAL(object->ce->namespaced_name.name)); } static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_illegal_array_offset_access(const zval *offset) @@ -1893,7 +1947,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_deprecated_function(const zend_functi if (fbc->common.scope) { zend_error_unchecked(code, "Method %s::%s() is deprecated%S", - ZSTR_VAL(fbc->common.scope->name), + ZSTR_VAL(fbc->common.scope->namespaced_name.name), ZSTR_VAL(fbc->common.function_name), message_suffix ); @@ -1920,7 +1974,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_deprecated_class_constant(const zend_ zend_error_unchecked(code, "%s %s::%s is deprecated%S", type, - ZSTR_VAL(c->ce->name), + ZSTR_VAL(c->ce->namespaced_name.name), ZSTR_VAL(constant_name), message_suffix ); @@ -2090,7 +2144,7 @@ static ZEND_COLD zend_long zend_throw_incdec_ref_error( if (ZEND_IS_INCREMENT(opline->opcode)) { zend_type_error( "Cannot increment a reference held by property %s::$%s of type %s past its maximal value", - ZSTR_VAL(error_prop->ce->name), + ZSTR_VAL(error_prop->ce->namespaced_name.name), zend_get_unmangled_property_name(error_prop->name), ZSTR_VAL(type_str)); zend_string_release(type_str); @@ -2098,7 +2152,7 @@ static ZEND_COLD zend_long zend_throw_incdec_ref_error( } else { zend_type_error( "Cannot decrement a reference held by property %s::$%s of type %s past its minimal value", - ZSTR_VAL(error_prop->ce->name), + ZSTR_VAL(error_prop->ce->namespaced_name.name), zend_get_unmangled_property_name(error_prop->name), ZSTR_VAL(type_str)); zend_string_release(type_str); @@ -2110,14 +2164,14 @@ static ZEND_COLD zend_long zend_throw_incdec_prop_error(zend_property_info *prop zend_string *type_str = zend_type_to_string(prop->type); if (ZEND_IS_INCREMENT(opline->opcode)) { zend_type_error("Cannot increment property %s::$%s of type %s past its maximal value", - ZSTR_VAL(prop->ce->name), + ZSTR_VAL(prop->ce->namespaced_name.name), zend_get_unmangled_property_name(prop->name), ZSTR_VAL(type_str)); zend_string_release(type_str); return ZEND_LONG_MAX; } else { zend_type_error("Cannot decrement property %s::$%s of type %s past its minimal value", - ZSTR_VAL(prop->ce->name), + ZSTR_VAL(prop->ce->namespaced_name.name), zend_get_unmangled_property_name(prop->name), ZSTR_VAL(type_str)); zend_string_release(type_str); @@ -2450,7 +2504,7 @@ ZEND_API ZEND_COLD zval* ZEND_FASTCALL zend_undefined_index_write(HashTable *ht, ZEND_API zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_undefined_method(const zend_class_entry *ce, const zend_string *method) { - zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->name), ZSTR_VAL(method)); + zend_throw_error(NULL, "Call to undefined method %s::%s()", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(method)); } static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_invalid_method_call(zval *object, zval *function_name) @@ -2464,7 +2518,7 @@ ZEND_API void ZEND_FASTCALL zend_non_static_method_call(const zend_function *fbc zend_throw_error( zend_ce_error, "Non-static method %s::%s() cannot be called statically", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + ZSTR_VAL(fbc->common.scope->namespaced_name.name), ZSTR_VAL(fbc->common.function_name)); } ZEND_COLD void ZEND_FASTCALL zend_param_must_be_ref(const zend_function *func, uint32_t arg_num) @@ -2472,7 +2526,7 @@ ZEND_COLD void ZEND_FASTCALL zend_param_must_be_ref(const zend_function *func, u const char *arg_name = get_function_arg_name(func, arg_num); zend_error(E_WARNING, "%s%s%s(): Argument #%d%s%s%s must be passed by reference, value given", - func->common.scope ? ZSTR_VAL(func->common.scope->name) : "", + func->common.scope ? ZSTR_VAL(func->common.scope->namespaced_name.name) : "", func->common.scope ? "::" : "", ZSTR_VAL(func->common.function_name), arg_num, @@ -2843,7 +2897,7 @@ static zend_always_inline void zend_fetch_dimension_address(zval *result, zval * zend_class_entry *ce = obj->ce; ZVAL_NULL(result); - zend_error(E_NOTICE, "Indirect modification of overloaded element of %s has no effect", ZSTR_VAL(ce->name)); + zend_error(E_NOTICE, "Indirect modification of overloaded element of %s has no effect", ZSTR_VAL(ce->namespaced_name.name)); } else if (EXPECTED(retval && Z_TYPE_P(retval) != IS_UNDEF)) { if (!Z_ISREF_P(retval)) { if (result != retval) { @@ -2852,7 +2906,7 @@ static zend_always_inline void zend_fetch_dimension_address(zval *result, zval * } if (Z_TYPE_P(retval) != IS_OBJECT) { zend_class_entry *ce = obj->ce; - zend_error(E_NOTICE, "Indirect modification of overloaded element of %s has no effect", ZSTR_VAL(ce->name)); + zend_error(E_NOTICE, "Indirect modification of overloaded element of %s has no effect", ZSTR_VAL(ce->namespaced_name.name)); } } else if (UNEXPECTED(Z_REFCOUNT_P(retval) == 1)) { ZVAL_UNREF(retval); @@ -3635,7 +3689,7 @@ static zend_always_inline zval* zend_fetch_static_property_address(zend_property && UNEXPECTED(Z_TYPE_P(result) == IS_UNDEF) && ZEND_TYPE_IS_SET(property_info->type)) { zend_throw_error(NULL, "Typed static property %s::$%s must not be accessed before initialization", - ZSTR_VAL(property_info->ce->name), + ZSTR_VAL(property_info->ce->namespaced_name.name), zend_get_unmangled_property_name(property_info->name)); return NULL; } @@ -3705,10 +3759,10 @@ ZEND_API ZEND_COLD void zend_throw_ref_type_error_type(const zend_property_info zend_string *type2_str = zend_type_to_string(prop2->type); zend_type_error("Reference with value of type %s held by property %s::$%s of type %s is not compatible with property %s::$%s of type %s", zend_zval_type_name(zv), - ZSTR_VAL(prop1->ce->name), + ZSTR_VAL(prop1->ce->namespaced_name.name), zend_get_unmangled_property_name(prop1->name), ZSTR_VAL(type1_str), - ZSTR_VAL(prop2->ce->name), + ZSTR_VAL(prop2->ce->namespaced_name.name), zend_get_unmangled_property_name(prop2->name), ZSTR_VAL(type2_str) ); @@ -3720,7 +3774,7 @@ ZEND_API ZEND_COLD void zend_throw_ref_type_error_zval(const zend_property_info zend_string *type_str = zend_type_to_string(prop->type); zend_type_error("Cannot assign %s to reference held by property %s::$%s of type %s", zend_zval_value_name(zv), - ZSTR_VAL(prop->ce->name), + ZSTR_VAL(prop->ce->namespaced_name.name), zend_get_unmangled_property_name(prop->name), ZSTR_VAL(type_str) ); @@ -3732,10 +3786,10 @@ ZEND_API ZEND_COLD void zend_throw_conflicting_coercion_error(const zend_propert zend_string *type2_str = zend_type_to_string(prop2->type); zend_type_error("Cannot assign %s to reference held by property %s::$%s of type %s and property %s::$%s of type %s, as this would result in an inconsistent type conversion", zend_zval_value_name(zv), - ZSTR_VAL(prop1->ce->name), + ZSTR_VAL(prop1->ce->namespaced_name.name), zend_get_unmangled_property_name(prop1->name), ZSTR_VAL(type1_str), - ZSTR_VAL(prop2->ce->name), + ZSTR_VAL(prop2->ce->namespaced_name.name), zend_get_unmangled_property_name(prop2->name), ZSTR_VAL(type2_str) ); @@ -4048,9 +4102,9 @@ static zend_never_inline void zend_fetch_this_var(int type OPLINE_DC EXECUTE_DAT static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_wrong_clone_call(zend_function *clone, zend_class_entry *scope) { zend_throw_error(NULL, "Call to %s %s::__clone() from %s%s", - zend_visibility_string(clone->common.fn_flags), ZSTR_VAL(clone->common.scope->name), + zend_visibility_string(clone->common.fn_flags), ZSTR_VAL(clone->common.scope->namespaced_name.name), scope ? "scope " : "global scope", - scope ? ZSTR_VAL(scope->name) : "" + scope ? ZSTR_VAL(scope->namespaced_name.name) : "" ); } @@ -5014,7 +5068,7 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_object(zend_o } } } else { - zend_throw_error(NULL, "Object of type %s is not callable", ZSTR_VAL(function->ce->name)); + zend_throw_error(NULL, "Object of type %s is not callable", ZSTR_VAL(function->ce->namespaced_name.name)); return NULL; } @@ -5210,7 +5264,7 @@ static zend_never_inline bool ZEND_FASTCALL zend_fe_reset_iterator(zval *array_p OBJ_RELEASE(&iter->std); } if (!EG(exception)) { - zend_throw_exception_ex(NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->namespaced_name.name)); } ZVAL_UNDEF(EX_VAR(opline->result.var)); return 1; diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 1f55521fb72f1..4244dec90a6c8 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -551,7 +551,7 @@ ZEND_API const char *get_active_class_name(const char **space) /* {{{ */ if (space) { *space = ce ? "::" : ""; } - return ce ? ZSTR_VAL(ce->name) : ""; + return ce ? ZSTR_VAL(ce->namespaced_name.name) : ""; } default: if (space) { @@ -618,7 +618,7 @@ ZEND_API zend_string *get_active_function_or_method_name(void) /* {{{ */ ZEND_API zend_string *get_function_or_method_name(const zend_function *func) /* {{{ */ { if (func->common.scope && func->common.function_name) { - return zend_create_member_string(func->common.scope->name, func->common.function_name); + return zend_create_member_string(func->common.scope->namespaced_name.name, func->common.function_name); } return func->common.function_name ? zend_string_copy(func->common.function_name) : ZSTR_INIT_LITERAL("main", 0); @@ -1103,7 +1103,7 @@ ZEND_API void zend_call_known_function( if (UNEXPECTED(result == FAILURE)) { if (!EG(exception)) { zend_error_noreturn(E_CORE_ERROR, "Couldn't execute method %s%s%s", - fn->common.scope ? ZSTR_VAL(fn->common.scope->name) : "", + fn->common.scope ? ZSTR_VAL(fn->common.scope->namespaced_name.name) : "", fn->common.scope ? "::" : "", ZSTR_VAL(fn->common.function_name)); } } @@ -1166,6 +1166,84 @@ ZEND_API bool zend_is_valid_class_name(zend_string *name) { return 1; } +static zend_class_entry *zend_resolve_nested_class(zend_string *requested_name, uint32_t flags) { + zend_class_entry *ce = NULL; + char *separator; + zend_string *scope_name = NULL; + + const char *unqualified_name = strrchr(ZSTR_VAL(requested_name), '|'); + if (unqualified_name == NULL) { + unqualified_name = strrchr(ZSTR_VAL(requested_name), '\\'); + if (unqualified_name == NULL) { + // there is not a nested class here... + return NULL; + } + } + + zend_string *inner_name = zend_string_init(unqualified_name + 1, ZSTR_LEN(requested_name) - (unqualified_name - ZSTR_VAL(requested_name) + 1), 0); + + scope_name = zend_string_init(ZSTR_VAL(requested_name), unqualified_name - ZSTR_VAL(requested_name) + 1, 0); + scope_name->val[scope_name->len - 1] = '\\'; // todo: there is probably a better way + + if (ZSTR_LEN(scope_name) == ZSTR_LEN(inner_name) + 1 && zend_string_starts_with_ci(scope_name, inner_name)) { + requested_name = zend_string_copy(inner_name); + } else { + requested_name = zend_string_concat2(ZSTR_VAL(scope_name), ZSTR_LEN(scope_name), ZSTR_VAL(inner_name), ZSTR_LEN(inner_name)); + } + + while ((separator = strrchr(ZSTR_VAL(scope_name), '\\'))) { + const size_t outer_len = separator - ZSTR_VAL(scope_name); + + zend_string *outer_class_name = zend_string_init(ZSTR_VAL(scope_name), outer_len, 0); + const zend_class_entry *outer_ce = zend_lookup_class_ex(outer_class_name, NULL, flags | ZEND_FETCH_CLASS_NO_INNER); + + if (outer_ce) { + // Outer class found; now explicitly check the requested class again + ce = zend_lookup_class_ex(requested_name, NULL, flags | ZEND_FETCH_CLASS_NO_INNER); + if (ce) { + zend_string_release(scope_name); + zend_string_release(outer_class_name); + zend_string_release(inner_name); + zend_string_release(requested_name); + return ce; + } + } + + // Check if the class is in the outer scope + char *outer_name = strrchr(ZSTR_VAL(outer_class_name), '\\'); + zend_string *outer_name_z; + if (!outer_name) { + outer_name_z = zend_string_copy(inner_name); + } else { + zend_string *tmp = zend_string_init(ZSTR_VAL(outer_class_name), outer_name - ZSTR_VAL(outer_class_name), 0); + outer_name_z = zend_string_concat3(ZSTR_VAL(tmp), ZSTR_LEN(tmp), "\\", 1, ZSTR_VAL(inner_name), ZSTR_LEN(inner_name)); + zend_string_release(tmp); + } + ce = zend_lookup_class_ex(outer_name_z, NULL, flags | ZEND_FETCH_CLASS_NO_INNER); + zend_string_release(outer_name_z); + zend_string_release(outer_class_name); + if (ce) { + zend_string_release(scope_name); + zend_string_release(inner_name); + zend_string_release(requested_name); + return ce; + } + + // Continue moving upwards (perhaps the inner class is further up) + zend_string *shorter_scope = zend_string_init(ZSTR_VAL(scope_name), outer_len, 0); + zend_string_release(scope_name); + scope_name = shorter_scope; + } + + zend_string_release(scope_name); + + // Final lookup directly at namespace/global scope + //ce = zend_lookup_class_ex(inner_name, NULL, flags | ZEND_FETCH_CLASS_NO_INNER); + zend_string_release(inner_name); + zend_string_release(requested_name); + return NULL; +} + ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, zend_string *key, uint32_t flags) /* {{{ */ { zend_class_entry *ce = NULL; @@ -1225,7 +1303,18 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, zend_string * return ce; } - /* The compiler is not-reentrant. Make sure we autoload only during run-time. */ + /* Check to see if our current scope is an outer class; if it is, we need to check the outer class's + * namespace for the class we're looking for. */ + if (!(flags & ZEND_FETCH_CLASS_NO_INNER)) { + ce = zend_resolve_nested_class(name, flags); + if (ce) { + if (!key) { + zend_string_release_ex(lc_name, 0); + } + return ce; + } + } + if ((flags & ZEND_FETCH_CLASS_NO_AUTOLOAD) || zend_is_compiling()) { if (!key) { zend_string_release_ex(lc_name, 0); diff --git a/Zend/zend_fibers.c b/Zend/zend_fibers.c index 97b7cdcc911b7..1e2e304af482c 100644 --- a/Zend/zend_fibers.c +++ b/Zend/zend_fibers.c @@ -1097,7 +1097,7 @@ ZEND_METHOD(FiberError, __construct) zend_throw_error( NULL, "The \"%s\" class is reserved for internal use and cannot be manually instantiated", - ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name) + ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->namespaced_name.name) ); } diff --git a/Zend/zend_fibers_arginfo.h b/Zend/zend_fibers_arginfo.h index 9db4db8d802af..acb4bdc1f07ca 100644 --- a/Zend/zend_fibers_arginfo.h +++ b/Zend/zend_fibers_arginfo.h @@ -73,8 +73,10 @@ static const zend_function_entry class_FiberError_methods[] = { static zend_class_entry *register_class_Fiber(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Fiber", class_Fiber_methods); + INIT_CLASS_NAME(namespaced_name, "Fiber"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Fiber_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -83,8 +85,10 @@ static zend_class_entry *register_class_Fiber(void) static zend_class_entry *register_class_FiberError(zend_class_entry *class_entry_Error) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "FiberError", class_FiberError_methods); + INIT_CLASS_NAME(namespaced_name, "FiberError"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_FiberError_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Error, ZEND_ACC_FINAL); return class_entry; diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c index a6ea91a7425b9..5db1f58cc6164 100644 --- a/Zend/zend_generators.c +++ b/Zend/zend_generators.c @@ -1080,7 +1080,7 @@ ZEND_METHOD(Generator, __debugInfo) zval val; if (func->common.scope) { - zend_string *class_name = func->common.scope->name; + zend_string *class_name = func->common.scope->namespaced_name.name; zend_string *func_name = func->common.function_name; zend_string *combined = zend_string_concat3( ZSTR_VAL(class_name), ZSTR_LEN(class_name), diff --git a/Zend/zend_generators_arginfo.h b/Zend/zend_generators_arginfo.h index 54a6744af1b64..b1483e4130772 100644 --- a/Zend/zend_generators_arginfo.h +++ b/Zend/zend_generators_arginfo.h @@ -53,8 +53,10 @@ static const zend_function_entry class_Generator_methods[] = { static zend_class_entry *register_class_Generator(zend_class_entry *class_entry_Iterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Generator", class_Generator_methods); + INIT_CLASS_NAME(namespaced_name, "Generator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Generator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Iterator); @@ -64,8 +66,10 @@ static zend_class_entry *register_class_Generator(zend_class_entry *class_entry_ static zend_class_entry *register_class_ClosedGeneratorException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ClosedGeneratorException", NULL); + INIT_CLASS_NAME(namespaced_name, "ClosedGeneratorException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, 0); return class_entry; diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index bcccf978e2a01..a9a4b11974797 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -190,8 +190,8 @@ static void do_inherit_parent_constructor(zend_class_entry *ce) /* {{{ */ if (ce->constructor) { if (parent->constructor && UNEXPECTED(parent->constructor->common.fn_flags & ZEND_ACC_FINAL)) { zend_error_noreturn(E_ERROR, "Cannot override final %s::%s() with %s::%s()", - ZSTR_VAL(parent->name), ZSTR_VAL(parent->constructor->common.function_name), - ZSTR_VAL(ce->name), ZSTR_VAL(ce->constructor->common.function_name)); + ZSTR_VAL(parent->namespaced_name.name), ZSTR_VAL(parent->constructor->common.function_name), + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(ce->constructor->common.function_name)); } return; } @@ -229,12 +229,12 @@ static zend_string *resolve_class_name(const zend_class_entry *scope, zend_strin ZEND_ASSERT(scope); if (zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_PARENT)) && scope->parent) { if (scope->ce_flags & ZEND_ACC_RESOLVED_PARENT) { - return scope->parent->name; + return scope->parent->namespaced_name.name; } else { - return scope->parent_name; + return scope->parent_name->name; } } else if (zend_string_equals_ci(name, ZSTR_KNOWN(ZEND_STR_SELF))) { - return scope->name; + return scope->namespaced_name.name; } else { return name; } @@ -274,7 +274,7 @@ static zend_class_entry *lookup_class_ex( if (register_unresolved && !ce) { zend_error_noreturn( E_COMPILE_ERROR, "%s must be registered before %s", - ZSTR_VAL(name), ZSTR_VAL(scope->name)); + ZSTR_VAL(name), ZSTR_VAL(scope->namespaced_name.name)); } return ce; @@ -297,7 +297,7 @@ static zend_class_entry *lookup_class_ex( } /* The current class may not be registered yet, so check for it explicitly. */ - if (zend_string_equals_ci(scope->name, name)) { + if (zend_string_equals_ci(scope->namespaced_name.name, name)) { return scope; } } @@ -324,7 +324,7 @@ static bool unlinked_instanceof(zend_class_entry *ce1, const zend_class_entry *c if (ce1->ce_flags & ZEND_ACC_RESOLVED_PARENT) { parent_ce = ce1->parent; } else { - parent_ce = zend_lookup_class_ex(ce1->parent_name, NULL, + parent_ce = zend_lookup_class_ex(ce1->parent_name->name, NULL, ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD); } @@ -348,7 +348,7 @@ static bool unlinked_instanceof(zend_class_entry *ce1, const zend_class_entry *c } else { for (i = 0; i < ce1->num_interfaces; i++) { zend_class_entry *ce = zend_lookup_class_ex( - ce1->interface_names[i].name, ce1->interface_names[i].lc_name, + ce1->interface_names[i].name, ce1->interface_names[i].resolved_name, ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD); /* Avoid recursing if class implements itself. */ if (ce && ce != ce1 && unlinked_instanceof(ce, ce2)) { @@ -922,9 +922,9 @@ static ZEND_COLD zend_string *zend_get_function_declaration( if (fptr->common.scope) { if (fptr->common.scope->ce_flags & ZEND_ACC_ANON_CLASS) { /* cut off on NULL byte ... class@anonymous */ - smart_str_appends(&str, ZSTR_VAL(fptr->common.scope->name)); + smart_str_appends(&str, ZSTR_VAL(fptr->common.scope->namespaced_name.name)); } else { - smart_str_appendl(&str, ZSTR_VAL(fptr->common.scope->name), ZSTR_LEN(fptr->common.scope->name)); + smart_str_appendl(&str, ZSTR_VAL(fptr->common.scope->namespaced_name.name), ZSTR_LEN(fptr->common.scope->namespaced_name.name)); } smart_str_appends(&str, "::"); } @@ -1087,7 +1087,7 @@ static void ZEND_COLD emit_incompatible_method_error( ZSTR_VAL(child_prototype), ZSTR_VAL(parent_prototype)); if (EG(exception)) { zend_exception_uncaught_error( - "During inheritance of %s", ZSTR_VAL(parent_scope->name)); + "During inheritance of %s", ZSTR_VAL(parent_scope->namespaced_name.name)); } } } else { @@ -1311,12 +1311,12 @@ static ZEND_COLD void emit_incompatible_property_error( zend_string *type_str = zend_type_to_string_resolved(parent->type, parent->ce); zend_error_noreturn(E_COMPILE_ERROR, "Type of %s::$%s must be %s%s (as in class %s)", - ZSTR_VAL(child->ce->name), + ZSTR_VAL(child->ce->namespaced_name.name), zend_get_unmangled_property_name(child->name), variance == PROP_INVARIANT ? "" : variance == PROP_COVARIANT ? "subtype of " : "supertype of ", ZSTR_VAL(type_str), - ZSTR_VAL(parent->ce->name)); + ZSTR_VAL(parent->ce->namespaced_name.name)); } static ZEND_COLD void emit_set_hook_type_error(const zend_property_info *child, const zend_property_info *parent) @@ -1325,11 +1325,11 @@ static ZEND_COLD void emit_set_hook_type_error(const zend_property_info *child, zend_string *type_str = zend_type_to_string_resolved(set_type, parent->ce); zend_error_noreturn(E_COMPILE_ERROR, "Set type of %s::$%s must be supertype of %s (as in %s %s)", - ZSTR_VAL(child->ce->name), + ZSTR_VAL(child->ce->namespaced_name.name), zend_get_unmangled_property_name(child->name), ZSTR_VAL(type_str), zend_get_object_type_case(parent->ce, false), - ZSTR_VAL(parent->ce->name)); + ZSTR_VAL(parent->ce->namespaced_name.name)); } static inheritance_status verify_property_type_compatibility( @@ -1415,7 +1415,7 @@ static void inherit_property_hook( if (parent_flags & ZEND_ACC_FINAL) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot override final property hook %s::%s()", - ZSTR_VAL(parent->common.scope->name), + ZSTR_VAL(parent->common.scope->namespaced_name.name), ZSTR_VAL(parent->common.function_name)); } @@ -1455,7 +1455,7 @@ static void do_inherit_property(zend_property_info *parent_info, zend_string *ke } if (parent_info->flags & ZEND_ACC_FINAL) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot override final property %s::$%s", - ZSTR_VAL(parent_info->ce->name), ZSTR_VAL(key)); + ZSTR_VAL(parent_info->ce->namespaced_name.name), ZSTR_VAL(key)); } if (!(parent_info->flags & ZEND_ACC_PRIVATE)) { if (!(parent_info->ce->ce_flags & ZEND_ACC_INTERFACE)) { @@ -1464,17 +1464,17 @@ static void do_inherit_property(zend_property_info *parent_info, zend_string *ke if (UNEXPECTED((parent_info->flags & ZEND_ACC_STATIC) != (child_info->flags & ZEND_ACC_STATIC))) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s%s::$%s as %s%s::$%s", - (parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ZSTR_VAL(parent_info->ce->name), ZSTR_VAL(key), - (child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ZSTR_VAL(ce->name), ZSTR_VAL(key)); + (parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ZSTR_VAL(parent_info->ce->namespaced_name.name), ZSTR_VAL(key), + (child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(key)); } if (UNEXPECTED((child_info->flags & ZEND_ACC_READONLY) != (parent_info->flags & ZEND_ACC_READONLY))) { if (!(parent_info->flags & ZEND_ACC_ABSTRACT)) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s property %s::$%s as %s %s::$%s", parent_info->flags & ZEND_ACC_READONLY ? "readonly" : "non-readonly", - ZSTR_VAL(parent_info->ce->name), ZSTR_VAL(key), + ZSTR_VAL(parent_info->ce->namespaced_name.name), ZSTR_VAL(key), child_info->flags & ZEND_ACC_READONLY ? "readonly" : "non-readonly", - ZSTR_VAL(ce->name), ZSTR_VAL(key)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(key)); } } if (UNEXPECTED((child_info->flags & ZEND_ACC_PPP_SET_MASK)) @@ -1491,14 +1491,14 @@ static void do_inherit_property(zend_property_info *parent_info, zend_string *ke zend_error_noreturn( E_COMPILE_ERROR, "Set access level of %s::$%s must be %s (as in class %s)%s", - ZSTR_VAL(ce->name), ZSTR_VAL(key), - zend_asymmetric_visibility_string(parent_info->flags), ZSTR_VAL(parent_info->ce->name), + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(key), + zend_asymmetric_visibility_string(parent_info->flags), ZSTR_VAL(parent_info->ce->namespaced_name.name), !(parent_info->flags & ZEND_ACC_PPP_SET_MASK) ? "" : " or weaker"); } } if (UNEXPECTED((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK))) { - zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ZSTR_VAL(ce->name), ZSTR_VAL(key), zend_visibility_string(parent_info->flags), ZSTR_VAL(parent_info->ce->name), (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker"); + zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(key), zend_visibility_string(parent_info->flags), ZSTR_VAL(parent_info->ce->namespaced_name.name), (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker"); } if (!(child_info->flags & ZEND_ACC_STATIC) && !(parent_info->flags & ZEND_ACC_VIRTUAL)) { /* If we added hooks to the child property, we use the child's slot for @@ -1558,9 +1558,9 @@ static void do_inherit_property(zend_property_info *parent_info, zend_string *ke } else if (UNEXPECTED(ZEND_TYPE_IS_SET(child_info->type) && !ZEND_TYPE_IS_SET(parent_info->type))) { zend_error_noreturn(E_COMPILE_ERROR, "Type of %s::$%s must be omitted to match the parent definition in class %s", - ZSTR_VAL(ce->name), + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(key), - ZSTR_VAL(parent_info->ce->name)); + ZSTR_VAL(parent_info->ce->namespaced_name.name)); } } } else { @@ -1580,7 +1580,7 @@ static void do_inherit_property(zend_property_info *parent_info, zend_string *ke static inline void do_implement_interface(zend_class_entry *ce, zend_class_entry *iface) /* {{{ */ { if (!(ce->ce_flags & ZEND_ACC_INTERFACE) && iface->interface_gets_implemented && iface->interface_gets_implemented(iface, ce) == FAILURE) { - zend_error_noreturn(E_CORE_ERROR, "%s %s could not implement interface %s", zend_get_object_type_uc(ce), ZSTR_VAL(ce->name), ZSTR_VAL(iface->name)); + zend_error_noreturn(E_CORE_ERROR, "%s %s could not implement interface %s", zend_get_object_type_uc(ce), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(iface->namespaced_name.name)); } /* This should be prevented by the class lookup logic. */ ZEND_ASSERT(ce != iface); @@ -1627,9 +1627,9 @@ static void emit_incompatible_class_constant_error( zend_string *type_str = zend_type_to_string_resolved(parent->type, parent->ce); zend_error_noreturn(E_COMPILE_ERROR, "Type of %s::%s must be compatible with %s::%s of type %s", - ZSTR_VAL(child->ce->name), + ZSTR_VAL(child->ce->namespaced_name.name), ZSTR_VAL(const_name), - ZSTR_VAL(parent->ce->name), + ZSTR_VAL(parent->ce->namespaced_name.name), ZSTR_VAL(const_name), ZSTR_VAL(type_str)); } @@ -1732,7 +1732,7 @@ ZEND_API void zend_verify_hooked_property(zend_class_entry *ce, zend_property_in prop_info->offset = ZEND_VIRTUAL_PROPERTY_OFFSET; } else { zend_error_noreturn(E_COMPILE_ERROR, - "Cannot specify default value for virtual hooked property %s::$%s", ZSTR_VAL(ce->name), ZSTR_VAL(prop_name)); + "Cannot specify default value for virtual hooked property %s::$%s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(prop_name)); } } /* If the property turns backed during inheritance and no type and default value are set, we want @@ -1750,7 +1750,7 @@ ZEND_API void zend_verify_hooked_property(zend_class_entry *ce, zend_property_in && !(prop_info->flags & ZEND_ACC_VIRTUAL) && prop_info->hooks[ZEND_PROPERTY_HOOK_SET]) { zend_error_noreturn(E_COMPILE_ERROR, "Get hook of backed property %s::%s with set hook may not return by reference", - ZSTR_VAL(ce->name), ZSTR_VAL(prop_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(prop_name)); } if (func->common.fn_flags & ZEND_ACC_ABSTRACT) { abstract_error = false; @@ -1759,7 +1759,7 @@ ZEND_API void zend_verify_hooked_property(zend_class_entry *ce, zend_property_in } if (abstract_error) { zend_error_noreturn(E_COMPILE_ERROR, - "Abstract property %s::$%s must specify at least one abstract hook", ZSTR_VAL(ce->name), ZSTR_VAL(prop_name)); + "Abstract property %s::$%s must specify at least one abstract hook", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(prop_name)); } if ((prop_info->flags & ZEND_ACC_VIRTUAL) && (prop_info->flags & ZEND_ACC_PPP_SET_MASK) @@ -1768,7 +1768,7 @@ ZEND_API void zend_verify_hooked_property(zend_class_entry *ce, zend_property_in ? "Write-only" : "Read-only"; zend_error_noreturn(E_COMPILE_ERROR, "%s virtual property %s::$%s must not specify asymmetric visibility", - prefix, ZSTR_VAL(ce->name), ZSTR_VAL(prop_name)); + prefix, ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(prop_name)); } } @@ -1781,7 +1781,7 @@ ZEND_API ZEND_COLD ZEND_NORETURN void zend_hooked_property_variance_error_ex(zen ZEND_API ZEND_COLD ZEND_NORETURN void zend_hooked_property_variance_error(const zend_property_info *prop_info) { zend_string *value_param_name = prop_info->hooks[ZEND_PROPERTY_HOOK_SET]->op_array.arg_info[0].name; - zend_hooked_property_variance_error_ex(value_param_name, prop_info->ce->name, prop_info->name); + zend_hooked_property_variance_error_ex(value_param_name, prop_info->ce->namespaced_name.name, prop_info->name); } ZEND_API inheritance_status zend_verify_property_hook_variance(const zend_property_info *prop_info, const zend_function *func) @@ -1831,36 +1831,36 @@ ZEND_API void zend_do_inheritance_ex(zend_class_entry *ce, zend_class_entry *par if (UNEXPECTED(ce->ce_flags & ZEND_ACC_INTERFACE)) { /* Interface can only inherit other interfaces */ if (UNEXPECTED(!(parent_ce->ce_flags & ZEND_ACC_INTERFACE))) { - zend_error_noreturn(E_COMPILE_ERROR, "Interface %s cannot extend class %s", ZSTR_VAL(ce->name), ZSTR_VAL(parent_ce->name)); + zend_error_noreturn(E_COMPILE_ERROR, "Interface %s cannot extend class %s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(parent_ce->namespaced_name.name)); } } else if (UNEXPECTED(parent_ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_FINAL|ZEND_ACC_ENUM))) { /* Class must not extend an enum (GH-16315); check enums first since * enums are implemented as final classes */ if (parent_ce->ce_flags & ZEND_ACC_ENUM) { - zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend enum %s", ZSTR_VAL(ce->name), ZSTR_VAL(parent_ce->name)); + zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend enum %s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(parent_ce->namespaced_name.name)); } /* Class must not extend a final class */ if (parent_ce->ce_flags & ZEND_ACC_FINAL) { - zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend final class %s", ZSTR_VAL(ce->name), ZSTR_VAL(parent_ce->name)); + zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend final class %s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(parent_ce->namespaced_name.name)); } /* Class declaration must not extend traits or interfaces */ if ((parent_ce->ce_flags & ZEND_ACC_INTERFACE) || (parent_ce->ce_flags & ZEND_ACC_TRAIT)) { zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend %s %s", - ZSTR_VAL(ce->name), parent_ce->ce_flags & ZEND_ACC_INTERFACE ? "interface" : "trait", ZSTR_VAL(parent_ce->name) + ZSTR_VAL(ce->namespaced_name.name), parent_ce->ce_flags & ZEND_ACC_INTERFACE ? "interface" : "trait", ZSTR_VAL(parent_ce->namespaced_name.name) ); } } if (UNEXPECTED((ce->ce_flags & ZEND_ACC_READONLY_CLASS) != (parent_ce->ce_flags & ZEND_ACC_READONLY_CLASS))) { zend_error_noreturn(E_COMPILE_ERROR, "%s class %s cannot extend %s class %s", - ce->ce_flags & ZEND_ACC_READONLY_CLASS ? "Readonly" : "Non-readonly", ZSTR_VAL(ce->name), - parent_ce->ce_flags & ZEND_ACC_READONLY_CLASS ? "readonly" : "non-readonly", ZSTR_VAL(parent_ce->name) + ce->ce_flags & ZEND_ACC_READONLY_CLASS ? "Readonly" : "Non-readonly", ZSTR_VAL(ce->namespaced_name.name), + parent_ce->ce_flags & ZEND_ACC_READONLY_CLASS ? "readonly" : "non-readonly", ZSTR_VAL(parent_ce->namespaced_name.name) ); } if (ce->parent_name) { - zend_string_release_ex(ce->parent_name, 0); + zend_string_release_ex(ce->parent_name->name, 0); } ce->parent = parent_ce; ce->default_object_handlers = parent_ce->default_object_handlers; @@ -2084,8 +2084,8 @@ static bool do_inherit_constant_check( zend_class_constant *child_constant = Z_PTR_P(zv); if (parent_constant->ce != child_constant->ce && (ZEND_CLASS_CONST_FLAGS(parent_constant) & ZEND_ACC_FINAL)) { zend_error_noreturn(E_COMPILE_ERROR, "%s::%s cannot override final constant %s::%s", - ZSTR_VAL(child_constant->ce->name), ZSTR_VAL(name), - ZSTR_VAL(parent_constant->ce->name), ZSTR_VAL(name) + ZSTR_VAL(child_constant->ce->namespaced_name.name), ZSTR_VAL(name), + ZSTR_VAL(parent_constant->ce->namespaced_name.name), ZSTR_VAL(name) ); } @@ -2093,17 +2093,17 @@ static bool do_inherit_constant_check( zend_error_noreturn(E_COMPILE_ERROR, "%s %s inherits both %s::%s and %s::%s, which is ambiguous", zend_get_object_type_uc(ce), - ZSTR_VAL(ce->name), - ZSTR_VAL(child_constant->ce->name), ZSTR_VAL(name), - ZSTR_VAL(parent_constant->ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), + ZSTR_VAL(child_constant->ce->namespaced_name.name), ZSTR_VAL(name), + ZSTR_VAL(parent_constant->ce->namespaced_name.name), ZSTR_VAL(name)); } if (UNEXPECTED((ZEND_CLASS_CONST_FLAGS(child_constant) & ZEND_ACC_PPP_MASK) > (ZEND_CLASS_CONST_FLAGS(parent_constant) & ZEND_ACC_PPP_MASK))) { zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::%s must be %s (as in %s %s)%s", - ZSTR_VAL(ce->name), ZSTR_VAL(name), + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name), zend_visibility_string(ZEND_CLASS_CONST_FLAGS(parent_constant)), zend_get_object_type(parent_constant->ce), - ZSTR_VAL(parent_constant->ce->name), + ZSTR_VAL(parent_constant->ce->namespaced_name.name), (ZEND_CLASS_CONST_FLAGS(parent_constant) & ZEND_ACC_PUBLIC) ? "" : " or weaker" ); } @@ -2207,7 +2207,7 @@ ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry if (EXPECTED(i < parent_iface_num)) { ignore = 1; } else { - zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ZSTR_VAL(ce->name), ZSTR_VAL(iface->name)); + zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(iface->namespaced_name.name)); } } } @@ -2247,7 +2247,7 @@ static void zend_do_implement_interfaces(zend_class_entry *ce, zend_class_entry } if (UNEXPECTED(!(iface->ce_flags & ZEND_ACC_INTERFACE))) { efree(interfaces); - zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ZSTR_VAL(ce->name), ZSTR_VAL(iface->name)); + zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(iface->namespaced_name.name)); return; } for (j = 0; j < num_interfaces; j++) { @@ -2256,8 +2256,8 @@ static void zend_do_implement_interfaces(zend_class_entry *ce, zend_class_entry efree(interfaces); zend_error_noreturn(E_COMPILE_ERROR, "%s %s cannot implement previously implemented interface %s", zend_get_object_type_uc(ce), - ZSTR_VAL(ce->name), - ZSTR_VAL(iface->name)); + ZSTR_VAL(ce->namespaced_name.name), + ZSTR_VAL(iface->namespaced_name.name)); return; } /* skip duplications */ @@ -2278,7 +2278,7 @@ static void zend_do_implement_interfaces(zend_class_entry *ce, zend_class_entry if (!(ce->ce_flags & ZEND_ACC_CACHED)) { for (i = 0; i < ce->num_interfaces; i++) { zend_string_release_ex(ce->interface_names[i].name, 0); - zend_string_release_ex(ce->interface_names[i].lc_name, 0); + zend_string_release_ex(ce->interface_names[i].resolved_name, 0); } efree(ce->interface_names); } @@ -2381,9 +2381,9 @@ static void zend_add_trait_method(zend_class_entry *ce, zend_string *name, zend_ && !(existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT))) { /* two traits can't define the same non-abstract method */ zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s::%s has not been applied as %s::%s, because of collision with %s::%s", - ZSTR_VAL(fn->common.scope->name), ZSTR_VAL(fn->common.function_name), - ZSTR_VAL(ce->name), ZSTR_VAL(name), - ZSTR_VAL(existing_fn->common.scope->name), ZSTR_VAL(existing_fn->common.function_name)); + ZSTR_VAL(fn->common.scope->namespaced_name.name), ZSTR_VAL(fn->common.function_name), + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name), + ZSTR_VAL(existing_fn->common.scope->namespaced_name.name), ZSTR_VAL(existing_fn->common.function_name)); } else { check_inheritance = true; } @@ -2526,7 +2526,7 @@ static uint32_t zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *t uint32_t i; if (UNEXPECTED((trait->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT)) { - zend_error_noreturn(E_COMPILE_ERROR, "Class %s is not a trait, Only traits may be used in 'as' and 'insteadof' statements", ZSTR_VAL(trait->name)); + zend_error_noreturn(E_COMPILE_ERROR, "Class %s is not a trait, Only traits may be used in 'as' and 'insteadof' statements", ZSTR_VAL(trait->namespaced_name.name)); return 0; } @@ -2535,7 +2535,7 @@ static uint32_t zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *t return i; } } - zend_error_noreturn(E_COMPILE_ERROR, "Required Trait %s wasn't added to %s", ZSTR_VAL(trait->name), ZSTR_VAL(ce->name)); + zend_error_noreturn(E_COMPILE_ERROR, "Required Trait %s wasn't added to %s", ZSTR_VAL(trait->namespaced_name.name), ZSTR_VAL(ce->namespaced_name.name)); return 0; } /* }}} */ @@ -2574,7 +2574,7 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce, zend_class_e if (!zend_hash_exists(&trait->function_table, lcname)) { zend_error_noreturn(E_COMPILE_ERROR, "A precedence rule was defined for %s::%s but this method does not exist", - ZSTR_VAL(trait->name), + ZSTR_VAL(trait->namespaced_name.name), ZSTR_VAL(cur_method_ref->method_name)); } @@ -2602,7 +2602,7 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce, zend_class_e zend_hash_init(exclude_tables[trait_num], 0, NULL, NULL, 0); } if (zend_hash_add_empty_element(exclude_tables[trait_num], lcname) == NULL) { - zend_error_noreturn(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", ZSTR_VAL(precedences[i]->trait_method.method_name), ZSTR_VAL(exclude_ce->name)); + zend_error_noreturn(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", ZSTR_VAL(precedences[i]->trait_method.method_name), ZSTR_VAL(exclude_ce->namespaced_name.name)); } /* make sure that the trait method is not from a class mentioned in @@ -2612,8 +2612,8 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce, zend_class_e "Inconsistent insteadof definition. " "The method %s is to be used from %s, but %s is also on the exclude list", ZSTR_VAL(cur_method_ref->method_name), - ZSTR_VAL(trait->name), - ZSTR_VAL(trait->name)); + ZSTR_VAL(trait->namespaced_name.name), + ZSTR_VAL(trait->namespaced_name.name)); } } zend_string_release_ex(lcname, 0); @@ -2635,9 +2635,7 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce, zend_class_e lcname = zend_string_tolower(cur_method_ref->method_name); if (cur_method_ref->class_name) { /* For all aliases with an explicit class name, resolve the class now. */ - lc_trait_name = zend_string_tolower(cur_method_ref->class_name); - trait = zend_hash_find_ptr(EG(class_table), lc_trait_name); - zend_string_release_ex(lc_trait_name, 0); + trait = zend_fetch_class(cur_method_ref->class_name, ZEND_FETCH_CLASS_NO_AUTOLOAD); if (!trait || !(trait->ce_flags & ZEND_ACC_LINKED)) { zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", ZSTR_VAL(cur_method_ref->class_name)); } @@ -2646,7 +2644,7 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce, zend_class_e /* And, ensure that the referenced method is resolvable, too. */ if (!zend_hash_exists(&trait->function_table, lcname)) { - zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", ZSTR_VAL(trait->name), ZSTR_VAL(cur_method_ref->method_name)); + zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", ZSTR_VAL(trait->namespaced_name.name), ZSTR_VAL(cur_method_ref->method_name)); } } else { /* Find out which trait this method refers to. */ @@ -2662,9 +2660,9 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce, zend_class_e zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for method %s(), which exists in both %s and %s. Use %s::%s or %s::%s to resolve the ambiguity", ZSTR_VAL(cur_method_ref->method_name), - ZSTR_VAL(trait->name), ZSTR_VAL(traits[j]->name), - ZSTR_VAL(trait->name), ZSTR_VAL(cur_method_ref->method_name), - ZSTR_VAL(traits[j]->name), ZSTR_VAL(cur_method_ref->method_name)); + ZSTR_VAL(trait->namespaced_name.name), ZSTR_VAL(traits[j]->namespaced_name.name), + ZSTR_VAL(trait->namespaced_name.name), ZSTR_VAL(cur_method_ref->method_name), + ZSTR_VAL(traits[j]->namespaced_name.name), ZSTR_VAL(cur_method_ref->method_name)); } } } @@ -2762,10 +2760,10 @@ static void emit_incompatible_trait_constant_error( ) { zend_error_noreturn(E_COMPILE_ERROR, "%s and %s define the same constant (%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed", - ZSTR_VAL(find_first_constant_definition(ce, traits, current_trait, name, existing_constant->ce)->name), - ZSTR_VAL(trait_constant->ce->name), + ZSTR_VAL(find_first_constant_definition(ce, traits, current_trait, name, existing_constant->ce)->namespaced_name.name), + ZSTR_VAL(trait_constant->ce->namespaced_name.name), ZSTR_VAL(name), - ZSTR_VAL(ce->name) + ZSTR_VAL(ce->namespaced_name.name) ); } @@ -2904,10 +2902,10 @@ static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_ent if (colliding_prop->hooks || property_info->hooks) { zend_error_noreturn(E_COMPILE_ERROR, "%s and %s define the same hooked property ($%s) in the composition of %s. Conflict resolution between hooked properties is currently not supported. Class was composed", - ZSTR_VAL(find_first_property_definition(ce, traits, i, prop_name, colliding_prop->ce)->name), - ZSTR_VAL(property_info->ce->name), + ZSTR_VAL(find_first_property_definition(ce, traits, i, prop_name, colliding_prop->ce)->namespaced_name.name), + ZSTR_VAL(property_info->ce->namespaced_name.name), ZSTR_VAL(prop_name), - ZSTR_VAL(ce->name)); + ZSTR_VAL(ce->namespaced_name.name)); } if ((colliding_prop->flags & flags_mask) == (flags & flags_mask) && @@ -2931,10 +2929,10 @@ static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_ent if (!is_compatible) { zend_error_noreturn(E_COMPILE_ERROR, "%s and %s define the same property ($%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed", - ZSTR_VAL(find_first_property_definition(ce, traits, i, prop_name, colliding_prop->ce)->name), - ZSTR_VAL(property_info->ce->name), + ZSTR_VAL(find_first_property_definition(ce, traits, i, prop_name, colliding_prop->ce)->namespaced_name.name), + ZSTR_VAL(property_info->ce->namespaced_name.name), ZSTR_VAL(prop_name), - ZSTR_VAL(ce->name)); + ZSTR_VAL(ce->namespaced_name.name)); } if (!(flags & ZEND_ACC_STATIC)) { continue; @@ -2945,8 +2943,8 @@ static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_ent if ((ce->ce_flags & ZEND_ACC_READONLY_CLASS) && !(property_info->flags & ZEND_ACC_READONLY)) { zend_error_noreturn(E_COMPILE_ERROR, "Readonly class %s cannot use trait with a non-readonly property %s::$%s", - ZSTR_VAL(ce->name), - ZSTR_VAL(property_info->ce->name), + ZSTR_VAL(ce->namespaced_name.name), + ZSTR_VAL(property_info->ce->namespaced_name.name), ZSTR_VAL(prop_name) ); } @@ -3096,7 +3094,7 @@ void zend_verify_abstract_class(zend_class_entry *ce) /* {{{ */ zend_error_noreturn(E_ERROR, "%s %s contains %d abstract method%s and must therefore be declared abstract or implement the remaining method%s (" MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT ")", zend_get_object_type_uc(ce), - ZSTR_VAL(ce->name), ai.cnt, + ZSTR_VAL(ce->namespaced_name.name), ai.cnt, ai.cnt > 1 ? "s" : "", ai.cnt > 1 ? "s" : "", DISPLAY_ABSTRACT_FN(0), @@ -3107,7 +3105,7 @@ void zend_verify_abstract_class(zend_class_entry *ce) /* {{{ */ zend_error_noreturn(E_ERROR, "%s %s must implement %d abstract method%s (" MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT ")", zend_get_object_type_uc(ce), - ZSTR_VAL(ce->name), ai.cnt, + ZSTR_VAL(ce->namespaced_name.name), ai.cnt, ai.cnt > 1 ? "s" : "", DISPLAY_ABSTRACT_FN(0), DISPLAY_ABSTRACT_FN(1), @@ -3315,7 +3313,7 @@ static void load_delayed_classes(zend_class_entry *ce) { if (EG(exception)) { zend_exception_uncaught_error( "During inheritance of %s, while autoloading %s", - ZSTR_VAL(ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } } } @@ -3348,7 +3346,7 @@ static void check_unrecoverable_load_failure(const zend_class_entry *ce) { if (CG(unlinked_uses) && zend_hash_index_del(CG(unlinked_uses), (zend_long)(uintptr_t)ce) == SUCCESS) { zend_exception_uncaught_error( - "During inheritance of %s with variance dependencies", ZSTR_VAL(ce->name)); + "During inheritance of %s with variance dependencies", ZSTR_VAL(ce->namespaced_name.name)); } } @@ -3532,7 +3530,7 @@ ZEND_API zend_class_entry *zend_do_link_class(zend_class_entry *ce, zend_string if (ce->parent_name) { parent = zend_fetch_class_by_name( - ce->parent_name, lc_parent_name, + ce->parent_name->name, lc_parent_name, ZEND_FETCH_CLASS_ALLOW_NEARLY_LINKED | ZEND_FETCH_CLASS_EXCEPTION); if (!parent) { check_unrecoverable_load_failure(ce); @@ -3546,13 +3544,13 @@ ZEND_API zend_class_entry *zend_do_link_class(zend_class_entry *ce, zend_string for (i = 0; i < ce->num_traits; i++) { zend_class_entry *trait = zend_fetch_class_by_name(ce->trait_names[i].name, - ce->trait_names[i].lc_name, ZEND_FETCH_CLASS_TRAIT | ZEND_FETCH_CLASS_EXCEPTION); + ce->trait_names[i].resolved_name, ZEND_FETCH_CLASS_TRAIT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(trait == NULL)) { free_alloca(traits_and_interfaces, use_heap); return NULL; } if (UNEXPECTED(!(trait->ce_flags & ZEND_ACC_TRAIT))) { - zend_throw_error(NULL, "%s cannot use %s - it is not a trait", ZSTR_VAL(ce->name), ZSTR_VAL(trait->name)); + zend_throw_error(NULL, "%s cannot use %s - it is not a trait", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(trait->namespaced_name.name)); free_alloca(traits_and_interfaces, use_heap); return NULL; } @@ -3573,7 +3571,7 @@ ZEND_API zend_class_entry *zend_do_link_class(zend_class_entry *ce, zend_string if (ce->num_interfaces) { for (i = 0; i < ce->num_interfaces; i++) { zend_class_entry *iface = zend_fetch_class_by_name( - ce->interface_names[i].name, ce->interface_names[i].lc_name, + ce->interface_names[i].name, ce->interface_names[i].resolved_name, ZEND_FETCH_CLASS_INTERFACE | ZEND_FETCH_CLASS_ALLOW_NEARLY_LINKED | ZEND_FETCH_CLASS_EXCEPTION); if (!iface) { @@ -3776,8 +3774,8 @@ ZEND_API zend_class_entry *zend_do_link_class(zend_class_entry *ce, zend_string free_alloca(traits_and_interfaces, use_heap); } - if (ZSTR_HAS_CE_CACHE(ce->name)) { - ZSTR_SET_CE_CACHE(ce->name, ce); + if (ZSTR_HAS_CE_CACHE(ce->namespaced_name.name)) { + ZSTR_SET_CE_CACHE(ce->namespaced_name.name, ce); } return ce; @@ -3979,8 +3977,8 @@ ZEND_API zend_class_entry *zend_try_early_bind(zend_class_entry *ce, zend_class_ } } - if (ZSTR_HAS_CE_CACHE(ce->name)) { - ZSTR_SET_CE_CACHE(ce->name, ce); + if (ZSTR_HAS_CE_CACHE(ce->namespaced_name.name)) { + ZSTR_SET_CE_CACHE(ce->namespaced_name.name, ce); } zend_observer_class_linked_notify(ce, lcname); diff --git a/Zend/zend_interfaces.c b/Zend/zend_interfaces.c index c0127feabbf68..639a3e644e477 100644 --- a/Zend/zend_interfaces.c +++ b/Zend/zend_interfaces.c @@ -58,7 +58,7 @@ ZEND_API zval* zend_call_method(zend_object *object, zend_class_entry *obj_ce, z &obj_ce->function_table, function_name, function_name_len); if (UNEXPECTED(fn == NULL)) { /* error at c-level */ - zend_error_noreturn(E_CORE_ERROR, "Couldn't find implementation for method %s::%s", ZSTR_VAL(obj_ce->name), function_name); + zend_error_noreturn(E_CORE_ERROR, "Couldn't find implementation for method %s::%s", ZSTR_VAL(obj_ce->namespaced_name.name), function_name); } } else { fn = zend_fetch_function_str(function_name, function_name_len); @@ -244,7 +244,7 @@ ZEND_API zend_object_iterator *zend_user_it_get_new_iterator(zend_class_entry *c if (!ce_it || !ce_it->get_iterator || (ce_it->get_iterator == zend_user_it_get_new_iterator && Z_OBJ(iterator) == Z_OBJ_P(object))) { if (!EG(exception)) { - zend_throw_exception_ex(NULL, 0, "Objects returned by %s::getIterator() must be traversable or implement interface Iterator", ce ? ZSTR_VAL(ce->name) : ZSTR_VAL(Z_OBJCE_P(object)->name)); + zend_throw_exception_ex(NULL, 0, "Objects returned by %s::getIterator() must be traversable or implement interface Iterator", ce ? ZSTR_VAL(ce->namespaced_name.name) : ZSTR_VAL(Z_OBJCE_P(object)->namespaced_name.name)); } zval_ptr_dtor(&iterator); return NULL; @@ -276,10 +276,10 @@ static int zend_implement_traversable(zend_class_entry *interface, zend_class_en } zend_error_noreturn(E_CORE_ERROR, "%s %s must implement interface %s as part of either %s or %s", zend_get_object_type_uc(class_type), - ZSTR_VAL(class_type->name), - ZSTR_VAL(zend_ce_traversable->name), - ZSTR_VAL(zend_ce_iterator->name), - ZSTR_VAL(zend_ce_aggregate->name)); + ZSTR_VAL(class_type->namespaced_name.name), + ZSTR_VAL(zend_ce_traversable->namespaced_name.name), + ZSTR_VAL(zend_ce_iterator->namespaced_name.name), + ZSTR_VAL(zend_ce_aggregate->namespaced_name.name)); return FAILURE; } /* }}} */ @@ -290,7 +290,7 @@ static int zend_implement_aggregate(zend_class_entry *interface, zend_class_entr if (zend_class_implements_interface(class_type, zend_ce_iterator)) { zend_error_noreturn(E_ERROR, "Class %s cannot implement both Iterator and IteratorAggregate at the same time", - ZSTR_VAL(class_type->name)); + ZSTR_VAL(class_type->namespaced_name.name)); } /* Always initialize iterator_funcs_ptr. */ @@ -332,7 +332,7 @@ static int zend_implement_iterator(zend_class_entry *interface, zend_class_entry if (zend_class_implements_interface(class_type, zend_ce_aggregate)) { zend_error_noreturn(E_ERROR, "Class %s cannot implement both Iterator and IteratorAggregate at the same time", - ZSTR_VAL(class_type->name)); + ZSTR_VAL(class_type->namespaced_name.name)); } ZEND_ASSERT(!class_type->iterator_funcs_ptr && "Iterator funcs already set?"); @@ -433,7 +433,7 @@ ZEND_API int zend_user_serialize(zval *object, unsigned char **buffer, size_t *b } if (result == FAILURE && !EG(exception)) { - zend_throw_exception_ex(NULL, 0, "%s::serialize() must return a string or NULL", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(NULL, 0, "%s::serialize() must return a string or NULL", ZSTR_VAL(ce->namespaced_name.name)); } return result; } @@ -477,10 +477,10 @@ static int zend_implement_serializable(zend_class_entry *interface, zend_class_e } if (!(class_type->ce_flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS) && (!class_type->__serialize || !class_type->__unserialize)) { - zend_error(E_DEPRECATED, "%s implements the Serializable interface, which is deprecated. Implement __serialize() and __unserialize() instead (or in addition, if support for old PHP versions is necessary)", ZSTR_VAL(class_type->name)); + zend_error(E_DEPRECATED, "%s implements the Serializable interface, which is deprecated. Implement __serialize() and __unserialize() instead (or in addition, if support for old PHP versions is necessary)", ZSTR_VAL(class_type->namespaced_name.name)); if (EG(exception)) { zend_exception_uncaught_error( - "During inheritance of %s, while implementing Serializable", ZSTR_VAL(class_type->name)); + "During inheritance of %s, while implementing Serializable", ZSTR_VAL(class_type->namespaced_name.name)); } } return SUCCESS; diff --git a/Zend/zend_interfaces_arginfo.h b/Zend/zend_interfaces_arginfo.h index 8a90166b2d800..d86ca97cea437 100644 --- a/Zend/zend_interfaces_arginfo.h +++ b/Zend/zend_interfaces_arginfo.h @@ -120,8 +120,10 @@ static const zend_function_entry class_InternalIterator_methods[] = { static zend_class_entry *register_class_Traversable(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Traversable", NULL); + INIT_CLASS_NAME(namespaced_name, "Traversable"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -130,8 +132,10 @@ static zend_class_entry *register_class_Traversable(void) static zend_class_entry *register_class_IteratorAggregate(zend_class_entry *class_entry_Traversable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IteratorAggregate", class_IteratorAggregate_methods); + INIT_CLASS_NAME(namespaced_name, "IteratorAggregate"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IteratorAggregate_methods); class_entry = zend_register_internal_interface(&ce); zend_class_implements(class_entry, 1, class_entry_Traversable); @@ -141,8 +145,10 @@ static zend_class_entry *register_class_IteratorAggregate(zend_class_entry *clas static zend_class_entry *register_class_Iterator(zend_class_entry *class_entry_Traversable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Iterator", class_Iterator_methods); + INIT_CLASS_NAME(namespaced_name, "Iterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Iterator_methods); class_entry = zend_register_internal_interface(&ce); zend_class_implements(class_entry, 1, class_entry_Traversable); @@ -152,8 +158,10 @@ static zend_class_entry *register_class_Iterator(zend_class_entry *class_entry_T static zend_class_entry *register_class_ArrayAccess(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ArrayAccess", class_ArrayAccess_methods); + INIT_CLASS_NAME(namespaced_name, "ArrayAccess"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ArrayAccess_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -162,8 +170,10 @@ static zend_class_entry *register_class_ArrayAccess(void) static zend_class_entry *register_class_Serializable(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Serializable", class_Serializable_methods); + INIT_CLASS_NAME(namespaced_name, "Serializable"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Serializable_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -172,8 +182,10 @@ static zend_class_entry *register_class_Serializable(void) static zend_class_entry *register_class_Countable(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Countable", class_Countable_methods); + INIT_CLASS_NAME(namespaced_name, "Countable"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Countable_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -182,8 +194,10 @@ static zend_class_entry *register_class_Countable(void) static zend_class_entry *register_class_Stringable(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Stringable", class_Stringable_methods); + INIT_CLASS_NAME(namespaced_name, "Stringable"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Stringable_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -192,8 +206,10 @@ static zend_class_entry *register_class_Stringable(void) static zend_class_entry *register_class_InternalIterator(zend_class_entry *class_entry_Iterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "InternalIterator", class_InternalIterator_methods); + INIT_CLASS_NAME(namespaced_name, "InternalIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_InternalIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Iterator); diff --git a/Zend/zend_iterators.c b/Zend/zend_iterators.c index f67033b11161c..95daaa59fc2c6 100644 --- a/Zend/zend_iterators.c +++ b/Zend/zend_iterators.c @@ -56,7 +56,9 @@ static const zend_object_handlers iterator_object_handlers = { ZEND_API void zend_register_iterator_wrapper(void) { - INIT_CLASS_ENTRY(zend_iterator_class_entry, "__iterator_wrapper", NULL); + zend_namespaced_name name; + INIT_CLASS_NAME(name, "__iterator_wrapper"); + INIT_CLASS_ENTRY(zend_iterator_class_entry, name, NULL); zend_iterator_class_entry.default_object_handlers = &iterator_object_handlers; } diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 1f117d142c158..0d190110f2c4a 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -275,7 +275,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type ctor_arguments alt_if_stmt_without_else trait_adaptation_list lexical_vars %type lexical_var_list encaps_list %type array_pair non_empty_array_pair_list array_pair_list possible_array_pair -%type isset_variable type return_type type_expr type_without_static +%type isset_variable type return_type type_expr type_without_static inner_type_without_static %type identifier type_expr_without_static union_type_without_static_element union_type_without_static intersection_type_without_static %type inline_function union_type_element union_type intersection_type %type attributed_statement attributed_class_statement attributed_parameter @@ -284,10 +284,10 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type enum_declaration_statement enum_backing_type enum_case enum_case_expr %type function_name non_empty_member_modifiers %type property_hook property_hook_list optional_property_hook_list hooked_property property_hook_body -%type optional_parameter_list +%type optional_parameter_list inner_class_statement %type returns_ref function fn is_reference is_variadic property_modifiers property_hook_modifiers -%type method_modifiers class_const_modifiers member_modifier optional_cpp_modifiers +%type method_modifiers class_const_modifiers member_modifier optional_cpp_modifiers inner_class_modifiers %type class_modifiers class_modifier anonymous_class_modifiers anonymous_class_modifiers_optional use_type backup_fn_flags %type backup_lex_pos @@ -626,6 +626,14 @@ class_modifier: | T_READONLY { $$ = ZEND_ACC_READONLY_CLASS|ZEND_ACC_NO_DYNAMIC_PROPERTIES; } ; +inner_class_modifiers: + non_empty_member_modifiers + { $$ = zend_modifier_list_to_flags(ZEND_MODIFIER_TARGET_INNER_CLASS, $1); + if (!$$) { YYERROR; } } + | %empty + { $$ = ZEND_ACC_PUBLIC; } +; + trait_declaration_statement: T_TRAIT { $$ = CG(zend_lineno); } T_STRING backup_doc_comment '{' class_statement_list '}' @@ -941,6 +949,10 @@ class_statement_list: { $$ = zend_ast_create_list(0, ZEND_AST_STMT_LIST); } ; +inner_class_statement: + T_CLASS T_STRING { $$ = CG(zend_lineno); } extends_from implements_list backup_doc_comment '{' class_statement_list '}' + { $$ = zend_ast_create_decl(ZEND_AST_CLASS, 0, $3, $6, zend_ast_get_str($2), $4, $5, $8, NULL, NULL); } +; attributed_class_statement: property_modifiers optional_type_without_static property_list ';' @@ -960,6 +972,8 @@ attributed_class_statement: { $$ = zend_ast_create_decl(ZEND_AST_METHOD, $3 | $1 | $12, $2, $5, zend_ast_get_str($4), $7, NULL, $11, $9, NULL); CG(extra_fn_flags) = $10; } | enum_case { $$ = $1; } + | inner_class_modifiers inner_class_statement + { $$ = $2; $$->attr = $1; } ; class_statement: @@ -1412,9 +1426,9 @@ class_name: ; class_name_reference: - class_name { $$ = $1; } - | new_variable { $$ = $1; } - | '(' expr ')' { $$ = $2; } + class_name { $$ = $1; } + | new_variable { $$ = $1; } + | '(' expr ')' { $$ = $2; } ; backticks_expr: diff --git a/Zend/zend_lazy_objects.c b/Zend/zend_lazy_objects.c index d1b950160e1cc..255baba4b3f44 100644 --- a/Zend/zend_lazy_objects.c +++ b/Zend/zend_lazy_objects.c @@ -235,14 +235,14 @@ ZEND_API zend_object *zend_object_make_lazy(zend_object *obj, /* Internal classes are not supported */ if (UNEXPECTED(reflection_ce->type == ZEND_INTERNAL_CLASS && reflection_ce != zend_standard_class_def)) { - zend_throw_error(NULL, "Cannot make instance of internal class lazy: %s is internal", ZSTR_VAL(reflection_ce->name)); + zend_throw_error(NULL, "Cannot make instance of internal class lazy: %s is internal", ZSTR_VAL(reflection_ce->namespaced_name.name)); return NULL; } for (zend_class_entry *parent = reflection_ce->parent; parent; parent = parent->parent) { if (UNEXPECTED(parent->type == ZEND_INTERNAL_CLASS && parent != zend_standard_class_def)) { zend_throw_error(NULL, "Cannot make instance of internal class lazy: %s inherits internal class %s", - ZSTR_VAL(reflection_ce->name), ZSTR_VAL(parent->name)); + ZSTR_VAL(reflection_ce->namespaced_name.name), ZSTR_VAL(parent->namespaced_name.name)); return NULL; } } @@ -499,7 +499,7 @@ static zend_object *zend_lazy_object_init_proxy(zend_object *obj) if (UNEXPECTED(Z_TYPE(retval) != IS_OBJECT)) { OBJ_EXTRA_FLAGS(obj) |= IS_OBJ_LAZY_UNINITIALIZED|IS_OBJ_LAZY_PROXY; zend_type_error("Lazy proxy factory must return an instance of a class compatible with %s, %s returned", - ZSTR_VAL(obj->ce->name), + ZSTR_VAL(obj->ce->namespaced_name.name), zend_zval_value_name(&retval)); zval_ptr_dtor(&retval); goto exit; @@ -509,7 +509,7 @@ static zend_object *zend_lazy_object_init_proxy(zend_object *obj) OBJ_EXTRA_FLAGS(obj) |= IS_OBJ_LAZY_UNINITIALIZED|IS_OBJ_LAZY_PROXY; zend_type_error("The real instance class %s is not compatible with the proxy class %s. The proxy must be a instance of the same class as the real instance, or a sub-class with no additional properties, and no overrides of the __destructor or __clone methods.", zend_zval_value_name(&retval), - ZSTR_VAL(obj->ce->name)); + ZSTR_VAL(obj->ce->namespaced_name.name)); zval_ptr_dtor(&retval); goto exit; } diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c index f2c2886eeb2be..061deec6d7fd7 100644 --- a/Zend/zend_object_handlers.c +++ b/Zend/zend_object_handlers.c @@ -298,7 +298,7 @@ static zend_never_inline zend_property_info *zend_get_parent_private_property(ze static ZEND_COLD zend_never_inline void zend_bad_property_access(const zend_property_info *property_info, const zend_class_entry *ce, const zend_string *member) /* {{{ */ { - zend_throw_error(NULL, "Cannot access %s property %s::$%s", zend_visibility_string(property_info->flags), ZSTR_VAL(ce->name), ZSTR_VAL(member)); + zend_throw_error(NULL, "Cannot access %s property %s::$%s", zend_visibility_string(property_info->flags), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(member)); } /* }}} */ @@ -311,21 +311,21 @@ static ZEND_COLD zend_never_inline void zend_bad_property_name(void) /* {{{ */ static ZEND_COLD zend_never_inline void zend_forbidden_dynamic_property( const zend_class_entry *ce, const zend_string *member) { zend_throw_error(NULL, "Cannot create dynamic property %s::$%s", - ZSTR_VAL(ce->name), ZSTR_VAL(member)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(member)); } static ZEND_COLD zend_never_inline bool zend_deprecated_dynamic_property( zend_object *obj, const zend_string *member) { GC_ADDREF(obj); zend_error(E_DEPRECATED, "Creation of dynamic property %s::$%s is deprecated", - ZSTR_VAL(obj->ce->name), ZSTR_VAL(member)); + ZSTR_VAL(obj->ce->namespaced_name.name), ZSTR_VAL(member)); if (UNEXPECTED(GC_DELREF(obj) == 0)) { zend_class_entry *ce = obj->ce; zend_objects_store_del(obj); if (!EG(exception)) { /* We cannot continue execution and have to throw an exception */ zend_throw_error(NULL, "Cannot create dynamic property %s::$%s", - ZSTR_VAL(ce->name), ZSTR_VAL(member)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(member)); } return 0; } @@ -335,7 +335,7 @@ static ZEND_COLD zend_never_inline bool zend_deprecated_dynamic_property( static ZEND_COLD zend_never_inline void zend_readonly_property_unset_error( zend_class_entry *ce, zend_string *member) { zend_throw_error(NULL, "Cannot unset readonly property %s::$%s", - ZSTR_VAL(ce->name), ZSTR_VAL(member)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(member)); } static zend_always_inline zend_class_entry *get_fake_or_executed_scope(void) @@ -381,6 +381,7 @@ static zend_always_inline uintptr_t zend_get_property_offset(zend_class_entry *c if (flags & (ZEND_ACC_CHANGED|ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED)) { zend_class_entry *scope = get_fake_or_executed_scope(); +check_lexical_scope: if (property_info->ce != scope) { if (flags & ZEND_ACC_CHANGED) { zend_property_info *p = zend_get_parent_private_property(scope, ce, member); @@ -402,6 +403,10 @@ static zend_always_inline uintptr_t zend_get_property_offset(zend_class_entry *c goto dynamic; } else { wrong: + if (scope && scope->lexical_scope) { + scope = scope->lexical_scope; + goto check_lexical_scope; + } /* Information was available, but we were denied access. Error out. */ if (!silent) { zend_bad_property_access(property_info, ce, member); @@ -420,7 +425,7 @@ static zend_always_inline uintptr_t zend_get_property_offset(zend_class_entry *c found: if (UNEXPECTED(flags & ZEND_ACC_STATIC)) { if (!silent) { - zend_error(E_NOTICE, "Accessing static property %s::$%s as non static", ZSTR_VAL(ce->name), ZSTR_VAL(member)); + zend_error(E_NOTICE, "Accessing static property %s::$%s as non static", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(member)); } return ZEND_DYNAMIC_PROPERTY_OFFSET; } @@ -515,7 +520,7 @@ ZEND_API zend_property_info *zend_get_property_info(const zend_class_entry *ce, found: if (UNEXPECTED(flags & ZEND_ACC_STATIC)) { if (!silent) { - zend_error(E_NOTICE, "Accessing static property %s::$%s as non static", ZSTR_VAL(ce->name), ZSTR_VAL(member)); + zend_error(E_NOTICE, "Accessing static property %s::$%s as non static", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(member)); } } return property_info; @@ -652,7 +657,7 @@ ZEND_API uint32_t *zend_get_recursion_guard(zend_object *zobj) ZEND_COLD static void zend_typed_property_uninitialized_access(const zend_property_info *prop_info, zend_string *name) { zend_throw_error(NULL, "Typed property %s::$%s must not be accessed before initialization", - ZSTR_VAL(prop_info->ce->name), + ZSTR_VAL(prop_info->ce->namespaced_name.name), ZSTR_VAL(name)); } @@ -705,7 +710,7 @@ static bool zend_call_get_hook( { if (!zend_should_call_hook(prop_info, zobj)) { if (UNEXPECTED(prop_info->flags & ZEND_ACC_VIRTUAL)) { - zend_throw_no_prop_backing_value_access(zobj->ce->name, prop_name, /* is_read */ true); + zend_throw_no_prop_backing_value_access(zobj->ce->namespaced_name.name, prop_name, /* is_read */ true); } return false; } @@ -794,7 +799,7 @@ ZEND_API zval *zend_std_read_property(zend_object *zobj, zend_string *name, int if (!get) { if (prop_info->flags & ZEND_ACC_VIRTUAL) { zend_throw_error(NULL, "Property %s::$%s is write-only", - ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name)); + ZSTR_VAL(zobj->ce->namespaced_name.name), ZSTR_VAL(name)); return &EG(uninitialized_zval); } /* Cache the fact that this hook has trivial read. This only applies to @@ -812,7 +817,7 @@ ZEND_API zval *zend_std_read_property(zend_object *zobj, zend_string *name, int if (UNEXPECTED(type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET)) { if (UNEXPECTED(Z_TYPE_P(retval) != IS_OBJECT)) { zend_throw_error(NULL, "Indirect modification of %s::$%s is not allowed", - ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name)); + ZSTR_VAL(zobj->ce->namespaced_name.name), ZSTR_VAL(name)); goto exit; } ZVAL_COPY(rv, retval); @@ -856,7 +861,7 @@ ZEND_API zval *zend_std_read_property(zend_object *zobj, zend_string *name, int && (type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET) && UNEXPECTED(Z_TYPE_P(rv) != IS_OBJECT)) { zend_throw_error(NULL, "Indirect modification of %s::$%s is not allowed", - ZSTR_VAL(ce->name), ZSTR_VAL(name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } } else { retval = &EG(uninitialized_zval); @@ -915,7 +920,7 @@ ZEND_API zval *zend_std_read_property(zend_object *zobj, zend_string *name, int if (!Z_ISREF_P(rv) && (type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET)) { if (UNEXPECTED(Z_TYPE_P(rv) != IS_OBJECT)) { - zend_error(E_NOTICE, "Indirect modification of overloaded property %s::$%s has no effect", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name)); + zend_error(E_NOTICE, "Indirect modification of overloaded property %s::$%s has no effect", ZSTR_VAL(zobj->ce->namespaced_name.name), ZSTR_VAL(name)); } } } else { @@ -953,7 +958,7 @@ ZEND_API zval *zend_std_read_property(zend_object *zobj, zend_string *name, int if (prop_info) { zend_typed_property_uninitialized_access(prop_info, name); } else { - zend_error(E_WARNING, "Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name)); + zend_error(E_WARNING, "Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->namespaced_name.name), ZSTR_VAL(name)); } } retval = &EG(uninitialized_zval); @@ -1086,7 +1091,7 @@ found:; if (!set) { if (prop_info->flags & ZEND_ACC_VIRTUAL) { - zend_throw_error(NULL, "Property %s::$%s is read-only", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name)); + zend_throw_error(NULL, "Property %s::$%s is read-only", ZSTR_VAL(zobj->ce->namespaced_name.name), ZSTR_VAL(name)); variable_ptr = &EG(error_zval); goto exit; } @@ -1100,7 +1105,7 @@ found:; if (!zend_should_call_hook(prop_info, zobj)) { if (prop_info->flags & ZEND_ACC_VIRTUAL) { - zend_throw_no_prop_backing_value_access(zobj->ce->name, name, /* is_read */ false); + zend_throw_no_prop_backing_value_access(zobj->ce->namespaced_name.name, name, /* is_read */ false); variable_ptr = &EG(error_zval); goto exit; } @@ -1223,7 +1228,7 @@ lazy_init:; static ZEND_COLD zend_never_inline void zend_bad_array_access(zend_class_entry *ce) /* {{{ */ { - zend_throw_error(NULL, "Cannot use object of type %s as array", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot use object of type %s as array", ZSTR_VAL(ce->namespaced_name.name)); } /* }}} */ @@ -1266,7 +1271,7 @@ ZEND_API zval *zend_std_read_dimension(zend_object *object, zval *offset, int ty if (UNEXPECTED(Z_TYPE_P(rv) == IS_UNDEF)) { if (UNEXPECTED(!EG(exception))) { - zend_throw_error(NULL, "Undefined offset for object of type %s used as array", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Undefined offset for object of type %s used as array", ZSTR_VAL(ce->namespaced_name.name)); } return NULL; } @@ -1361,7 +1366,7 @@ ZEND_API zval *zend_std_get_property_ptr_ptr(zend_object *zobj, zend_string *nam zend_typed_property_uninitialized_access(prop_info, name); retval = &EG(error_zval); } else { - zend_error(E_WARNING, "Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name)); + zend_error(E_WARNING, "Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->namespaced_name.name), ZSTR_VAL(name)); /* An error handler may set the property */ if (EXPECTED(Z_TYPE_P(retval) == IS_UNDEF)) { ZVAL_NULL(retval); @@ -1418,7 +1423,7 @@ ZEND_API zval *zend_std_get_property_ptr_ptr(zend_object *zobj, zend_string *nam rebuild_object_properties_internal(zobj); } if (UNEXPECTED(type == BP_VAR_RW || type == BP_VAR_R)) { - zend_error(E_WARNING, "Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name)); + zend_error(E_WARNING, "Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->namespaced_name.name), ZSTR_VAL(name)); } retval = zend_hash_add(zobj->properties, name, &EG(uninitialized_zval)); } @@ -1506,7 +1511,7 @@ ZEND_API void zend_std_unset_property(zend_object *zobj, zend_string *name, void } } else if (IS_HOOKED_PROPERTY_OFFSET(property_offset)) { zend_throw_error(NULL, "Cannot unset hooked property %s::$%s", - ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name)); + ZSTR_VAL(zobj->ce->namespaced_name.name), ZSTR_VAL(name)); return; } else if (UNEXPECTED(EG(exception))) { return; @@ -1768,7 +1773,7 @@ ZEND_API ZEND_COLD zend_never_inline void zend_bad_method_call(zend_function *fb zend_throw_error(NULL, "Call to %s method %s::%s() from %s%s", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(method_name), scope ? "scope " : "global scope", - scope ? ZSTR_VAL(scope->name) : "" + scope ? ZSTR_VAL(scope->namespaced_name.name) : "" ); } /* }}} */ @@ -1776,7 +1781,7 @@ ZEND_API ZEND_COLD zend_never_inline void zend_bad_method_call(zend_function *fb ZEND_API ZEND_COLD zend_never_inline void zend_abstract_method_call(zend_function *fbc) /* {{{ */ { zend_throw_error(NULL, "Cannot call abstract method %s::%s()", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + ZSTR_VAL(fbc->common.scope->namespaced_name.name), ZSTR_VAL(fbc->common.function_name)); } /* }}} */ @@ -1815,6 +1820,8 @@ ZEND_API zend_function *zend_std_get_method(zend_object **obj_ptr, zend_string * /* Check access level */ if (fbc->op_array.fn_flags & (ZEND_ACC_CHANGED|ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED)) { scope = zend_get_executed_scope(); + zend_class_entry *original_scope = scope; +check_lexical_scope: if (fbc->common.scope != scope) { if (fbc->op_array.fn_flags & ZEND_ACC_CHANGED) { @@ -1832,7 +1839,11 @@ ZEND_API zend_function *zend_std_get_method(zend_object **obj_ptr, zend_string * if (zobj->ce->__call) { fbc = zend_get_user_call_function(zobj->ce, method_name); } else { - zend_bad_method_call(fbc, method_name, scope); + if (scope && scope->lexical_scope) { + scope = scope->lexical_scope; + goto check_lexical_scope; + } + zend_bad_method_call(fbc, method_name, original_scope); fbc = NULL; } } @@ -1891,12 +1902,19 @@ ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_st fbc = Z_FUNC_P(func); if (!(fbc->op_array.fn_flags & ZEND_ACC_PUBLIC)) { zend_class_entry *scope = zend_get_executed_scope(); + zend_class_entry *original_scope = scope; +check_lexical_scope: if (UNEXPECTED(fbc->common.scope != scope)) { if (UNEXPECTED(fbc->op_array.fn_flags & ZEND_ACC_PRIVATE) || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), scope))) { zend_function *fallback_fbc = get_static_method_fallback(ce, function_name); if (!fallback_fbc) { - zend_bad_method_call(fbc, function_name, scope); + if (scope && scope->lexical_scope) { + scope = scope->lexical_scope; + goto check_lexical_scope; + } + + zend_bad_method_call(fbc, function_name, original_scope); } fbc = fallback_fbc; } @@ -1918,7 +1936,7 @@ ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_st zend_error(E_DEPRECATED, "Calling static trait method %s::%s is deprecated, " "it should only be called on a class using the trait", - ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + ZSTR_VAL(fbc->common.scope->namespaced_name.name), ZSTR_VAL(fbc->common.function_name)); if (EG(exception)) { goto fail; } @@ -1973,10 +1991,15 @@ ZEND_API zval *zend_std_get_static_property_with_info(zend_class_entry *ce, zend if (!(property_info->flags & ZEND_ACC_PUBLIC)) { zend_class_entry *scope = get_fake_or_executed_scope(); +check_lexical_scope: if (property_info->ce != scope) { if (UNEXPECTED(property_info->flags & ZEND_ACC_PRIVATE) || UNEXPECTED(!is_protected_compatible_scope(property_info->ce, scope))) { if (type != BP_VAR_IS) { + if (scope && scope->lexical_scope) { + scope = scope->lexical_scope; + goto check_lexical_scope; + } zend_bad_property_access(property_info, ce, property_name); } return NULL; @@ -1987,7 +2010,7 @@ ZEND_API zval *zend_std_get_static_property_with_info(zend_class_entry *ce, zend if (UNEXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0)) { undeclared_property: if (type != BP_VAR_IS) { - zend_throw_error(NULL, "Access to undeclared static property %s::$%s", ZSTR_VAL(ce->name), ZSTR_VAL(property_name)); + zend_throw_error(NULL, "Access to undeclared static property %s::$%s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(property_name)); } return NULL; } @@ -2009,7 +2032,7 @@ ZEND_API zval *zend_std_get_static_property_with_info(zend_class_entry *ce, zend if (UNEXPECTED((type == BP_VAR_R || type == BP_VAR_RW) && Z_TYPE_P(ret) == IS_UNDEF && ZEND_TYPE_IS_SET(property_info->type))) { zend_throw_error(NULL, "Typed static property %s::$%s must not be accessed before initialization", - ZSTR_VAL(property_info->ce->name), ZSTR_VAL(property_name)); + ZSTR_VAL(property_info->ce->namespaced_name.name), ZSTR_VAL(property_name)); return NULL; } @@ -2017,7 +2040,7 @@ ZEND_API zval *zend_std_get_static_property_with_info(zend_class_entry *ce, zend zend_error(E_DEPRECATED, "Accessing static trait property %s::$%s is deprecated, " "it should only be accessed on a class using the trait", - ZSTR_VAL(property_info->ce->name), ZSTR_VAL(property_name)); + ZSTR_VAL(property_info->ce->namespaced_name.name), ZSTR_VAL(property_name)); } return ret; @@ -2032,7 +2055,7 @@ ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *p ZEND_API ZEND_COLD bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name) /* {{{ */ { - zend_throw_error(NULL, "Attempt to unset static property %s::$%s", ZSTR_VAL(ce->name), ZSTR_VAL(property_name)); + zend_throw_error(NULL, "Attempt to unset static property %s::$%s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(property_name)); return 0; } /* }}} */ @@ -2041,11 +2064,11 @@ static ZEND_COLD zend_never_inline void zend_bad_constructor_call(zend_function { if (scope) { zend_throw_error(NULL, "Call to %s %s::%s() from scope %s", - zend_visibility_string(constructor->common.fn_flags), ZSTR_VAL(constructor->common.scope->name), - ZSTR_VAL(constructor->common.function_name), ZSTR_VAL(scope->name) + zend_visibility_string(constructor->common.fn_flags), ZSTR_VAL(constructor->common.scope->namespaced_name.name), + ZSTR_VAL(constructor->common.function_name), ZSTR_VAL(scope->namespaced_name.name) ); } else { - zend_throw_error(NULL, "Call to %s %s::%s() from global scope", zend_visibility_string(constructor->common.fn_flags), ZSTR_VAL(constructor->common.scope->name), ZSTR_VAL(constructor->common.function_name)); + zend_throw_error(NULL, "Call to %s %s::%s() from global scope", zend_visibility_string(constructor->common.fn_flags), ZSTR_VAL(constructor->common.scope->namespaced_name.name), ZSTR_VAL(constructor->common.function_name)); } } /* }}} */ @@ -2057,9 +2080,15 @@ ZEND_API zend_function *zend_std_get_constructor(zend_object *zobj) /* {{{ */ if (constructor) { if (UNEXPECTED(!(constructor->op_array.fn_flags & ZEND_ACC_PUBLIC))) { zend_class_entry *scope = get_fake_or_executed_scope(); +check_lexical_scope: if (UNEXPECTED(constructor->common.scope != scope)) { if (UNEXPECTED(constructor->op_array.fn_flags & ZEND_ACC_PRIVATE) || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(constructor), scope))) { + if (scope && scope->lexical_scope) { + scope = scope->lexical_scope; + goto check_lexical_scope; + } + zend_bad_constructor_call(constructor, scope); zend_object_store_ctor_failed(zobj); constructor = NULL; @@ -2099,7 +2128,7 @@ ZEND_API int zend_std_compare_objects(zval *o1, zval *o2) /* {{{ */ // TODO: Less crazy. if (target_type == IS_LONG || target_type == IS_DOUBLE) { zend_error(E_NOTICE, "Object of class %s could not be converted to %s", - ZSTR_VAL(Z_OBJCE_P(object)->name), zend_get_type_by_const(target_type)); + ZSTR_VAL(Z_OBJCE_P(object)->namespaced_name.name), zend_get_type_by_const(target_type)); if (target_type == IS_LONG) { ZVAL_LONG(&casted, 1); } else { @@ -2263,7 +2292,7 @@ ZEND_API int zend_std_has_property(zend_object *zobj, zend_string *name, int has if (!get) { if (prop_info->flags & ZEND_ACC_VIRTUAL) { zend_throw_error(NULL, "Property %s::$%s is write-only", - ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name)); + ZSTR_VAL(zobj->ce->namespaced_name.name), ZSTR_VAL(name)); return 0; } else { property_offset = prop_info->offset; @@ -2350,7 +2379,7 @@ ZEND_API int zend_std_has_property(zend_object *zobj, zend_string *name, int has ZEND_API zend_string *zend_std_get_class_name(const zend_object *zobj) /* {{{ */ { - return zend_string_copy(zobj->ce->name); + return zend_string_copy(zobj->ce->namespaced_name.name); } /* }}} */ @@ -2370,7 +2399,7 @@ ZEND_API zend_result zend_std_cast_object_tostring(zend_object *readobj, zval *w } zval_ptr_dtor(&retval); if (!EG(exception)) { - zend_throw_error(NULL, "Method %s::__toString() must return a string value", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Method %s::__toString() must return a string value", ZSTR_VAL(ce->namespaced_name.name)); } } return FAILURE; diff --git a/Zend/zend_objects.c b/Zend/zend_objects.c index fd0e97c5f4131..1a7a5dcfd8bf4 100644 --- a/Zend/zend_objects.c +++ b/Zend/zend_objects.c @@ -133,16 +133,16 @@ ZEND_API void zend_objects_destroy_object(zend_object *object) if (object->ce != scope) { zend_throw_error(NULL, "Call to private %s::__destruct() from %s%s", - ZSTR_VAL(object->ce->name), + ZSTR_VAL(object->ce->namespaced_name.name), scope ? "scope " : "global scope", - scope ? ZSTR_VAL(scope->name) : "" + scope ? ZSTR_VAL(scope->namespaced_name.name) : "" ); return; } } else { zend_error(E_WARNING, "Call to private %s::__destruct() from global scope during shutdown ignored", - ZSTR_VAL(object->ce->name)); + ZSTR_VAL(object->ce->namespaced_name.name)); return; } } else { @@ -154,16 +154,16 @@ ZEND_API void zend_objects_destroy_object(zend_object *object) if (!zend_check_protected(zend_get_function_root_class(destructor), scope)) { zend_throw_error(NULL, "Call to protected %s::__destruct() from %s%s", - ZSTR_VAL(object->ce->name), + ZSTR_VAL(object->ce->namespaced_name.name), scope ? "scope " : "global scope", - scope ? ZSTR_VAL(scope->name) : "" + scope ? ZSTR_VAL(scope->namespaced_name.name) : "" ); return; } } else { zend_error(E_WARNING, "Call to protected %s::__destruct() from global scope during shutdown ignored", - ZSTR_VAL(object->ce->name)); + ZSTR_VAL(object->ce->namespaced_name.name)); return; } } diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index f32ae13e06793..39de51406b612 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -205,7 +205,7 @@ static void _destroy_zend_class_traits_info(zend_class_entry *ce) for (i = 0; i < ce->num_traits; i++) { zend_string_release_ex(ce->trait_names[i].name, 0); - zend_string_release_ex(ce->trait_names[i].lc_name, 0); + zend_string_release_ex(ce->trait_names[i].resolved_name, 0); } efree(ce->trait_names); @@ -337,10 +337,10 @@ ZEND_API void destroy_zend_class(zval *zv) case ZEND_USER_CLASS: if (!(ce->ce_flags & ZEND_ACC_CACHED)) { if (ce->parent_name && !(ce->ce_flags & ZEND_ACC_RESOLVED_PARENT)) { - zend_string_release_ex(ce->parent_name, 0); + zend_string_release_ex(ce->parent_name->name, 0); } - zend_string_release_ex(ce->name, 0); + zend_string_release_ex(ce->namespaced_name.name, 0); zend_string_release_ex(ce->info.user.filename, 0); if (ce->doc_comment) { @@ -356,7 +356,7 @@ ZEND_API void destroy_zend_class(zval *zv) for (i = 0; i < ce->num_interfaces; i++) { zend_string_release_ex(ce->interface_names[i].name, 0); - zend_string_release_ex(ce->interface_names[i].lc_name, 0); + zend_string_release_ex(ce->interface_names[i].resolved_name, 0); } efree(ce->interface_names); } @@ -430,6 +430,9 @@ ZEND_API void destroy_zend_class(zval *zv) if (ce->backed_enum_table) { zend_hash_release(ce->backed_enum_table); } + if (ce->required_scope) { + ce->required_scope = NULL; + } break; case ZEND_INTERNAL_CLASS: if (ce->doc_comment) { @@ -471,7 +474,7 @@ ZEND_API void destroy_zend_class(zval *zv) } } ZEND_HASH_FOREACH_END(); zend_hash_destroy(&ce->properties_info); - zend_string_release_ex(ce->name, 1); + zend_string_release_ex(ce->namespaced_name.name, 1); /* TODO: eliminate this loop for classes without functions with arg_info / attributes */ ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, fn) { diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index 879141d1a139e..0e2be7cb3b94f 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -233,7 +233,7 @@ ZEND_API int ZEND_FASTCALL zend_atoi(const char *str, size_t str_len) ZVAL_UNDEF(dst); \ if (Z_OBJ_HT_P(op)->cast_object(Z_OBJ_P(op), dst, ctype) == FAILURE) { \ zend_error(E_WARNING, \ - "Object of class %s could not be converted to %s", ZSTR_VAL(Z_OBJCE_P(op)->name),\ + "Object of class %s could not be converted to %s", ZSTR_VAL(Z_OBJCE_P(op)->namespaced_name.name),\ zend_get_type_by_const(ctype)); \ } \ @@ -765,7 +765,7 @@ ZEND_API void ZEND_FASTCALL _convert_to_string(zval *op) /* {{{ */ return; } if (!EG(exception)) { - zend_throw_error(NULL, "Object of class %s could not be converted to string", ZSTR_VAL(Z_OBJCE_P(op)->name)); + zend_throw_error(NULL, "Object of class %s could not be converted to string", ZSTR_VAL(Z_OBJCE_P(op)->namespaced_name.name)); } zval_ptr_dtor(op); ZVAL_EMPTY_STRING(op); @@ -1033,7 +1033,7 @@ static zend_always_inline zend_string* __zval_get_string_func(zval *op, bool try return Z_STR(tmp); } if (!EG(exception)) { - zend_throw_error(NULL, "Object of class %s could not be converted to string", ZSTR_VAL(Z_OBJCE_P(op)->name)); + zend_throw_error(NULL, "Object of class %s could not be converted to string", ZSTR_VAL(Z_OBJCE_P(op)->namespaced_name.name)); } return try ? NULL : ZSTR_EMPTY_ALLOC(); } @@ -2848,7 +2848,7 @@ ZEND_API bool ZEND_FASTCALL zend_object_is_true(const zval *op) /* {{{ */ if (zobj->handlers->cast_object(zobj, &tmp, _IS_BOOL) == SUCCESS) { return Z_TYPE(tmp) == IS_TRUE; } - zend_error(E_RECOVERABLE_ERROR, "Object of class %s could not be converted to bool", ZSTR_VAL(zobj->ce->name)); + zend_error(E_RECOVERABLE_ERROR, "Object of class %s could not be converted to bool", ZSTR_VAL(zobj->ce->namespaced_name.name)); return false; } /* }}} */ diff --git a/Zend/zend_property_hooks.c b/Zend/zend_property_hooks.c index 01a8afb169373..3d5802e08f5f6 100644 --- a/Zend/zend_property_hooks.c +++ b/Zend/zend_property_hooks.c @@ -168,7 +168,7 @@ static void zho_declared_it_fetch_current(zend_object_iterator *iter) && (get == NULL || !(get->common.fn_flags & ZEND_ACC_RETURN_REFERENCE))) { zend_throw_error(NULL, "Cannot create reference to property %s::$%s", - ZSTR_VAL(zobj->ce->name), zend_get_unmangled_property_name(prop_info->name)); + ZSTR_VAL(zobj->ce->namespaced_name.name), zend_get_unmangled_property_name(prop_info->name)); return; } zend_string *unmangled_name = prop_info->name; @@ -197,7 +197,7 @@ static void zho_declared_it_fetch_current(zend_object_iterator *iter) if (UNEXPECTED(prop_info->flags & ZEND_ACC_READONLY)) { zend_throw_error(NULL, "Cannot acquire reference to readonly property %s::$%s", - ZSTR_VAL(prop_info->ce->name), zend_get_unmangled_property_name(prop_info->name)); + ZSTR_VAL(prop_info->ce->namespaced_name.name), zend_get_unmangled_property_name(prop_info->name)); return; } ZVAL_MAKE_REF(property); diff --git a/Zend/zend_smart_str.c b/Zend/zend_smart_str.c index ade137a4bb6c3..4d4b692ff05a1 100644 --- a/Zend/zend_smart_str.c +++ b/Zend/zend_smart_str.c @@ -37,7 +37,7 @@ ZEND_API void ZEND_FASTCALL smart_str_erealloc(smart_str *str, size_t len) ZSTR_LEN(str->s) = 0; } else { str->a = SMART_STR_NEW_LEN(len); - str->s = (zend_string *) erealloc2(str->s, str->a + _ZSTR_HEADER_SIZE + 1, _ZSTR_HEADER_SIZE + ZSTR_LEN(str->s)); + str->s = *(zend_string **) erealloc2(str->s, str->a + _ZSTR_HEADER_SIZE + 1, _ZSTR_HEADER_SIZE + ZSTR_LEN(str->s)); } } @@ -51,7 +51,7 @@ ZEND_API void ZEND_FASTCALL smart_str_realloc(smart_str *str, size_t len) ZSTR_LEN(str->s) = 0; } else { str->a = SMART_STR_NEW_LEN(len); - str->s = (zend_string *) perealloc(str->s, str->a + _ZSTR_HEADER_SIZE + 1, 1); + str->s = *(zend_string **) perealloc(str->s, str->a + _ZSTR_HEADER_SIZE + 1, 1); } } @@ -228,7 +228,7 @@ ZEND_API zend_result ZEND_FASTCALL smart_str_append_zval(smart_str *dest, const if (Z_TYPE_P(value) <= IS_STRING) { smart_str_append_scalar(dest, value, truncate); } else if (Z_TYPE_P(value) == IS_OBJECT && (Z_OBJCE_P(value)->ce_flags & ZEND_ACC_ENUM)) { - smart_str_append(dest, Z_OBJCE_P(value)->name); + smart_str_append(dest, Z_OBJCE_P(value)->namespaced_name.name); smart_str_appends(dest, "::"); smart_str_append(dest, Z_STR_P(zend_enum_fetch_case_name(Z_OBJ_P(value)))); } else { diff --git a/Zend/zend_string.h b/Zend/zend_string.h index e9e2b947a6c91..8a259b7bbcc3e 100644 --- a/Zend/zend_string.h +++ b/Zend/zend_string.h @@ -117,7 +117,7 @@ END_EXTERN_C() #define ZSTR_MAX_LEN (SIZE_MAX - ZSTR_MAX_OVERHEAD) #define ZSTR_ALLOCA_ALLOC(str, _len, use_heap) do { \ - (str) = (zend_string *)do_alloca(ZEND_MM_ALIGNED_SIZE_EX(_ZSTR_STRUCT_SIZE(_len), 8), (use_heap)); \ + (str) = *(zend_string **)do_alloca(ZEND_MM_ALIGNED_SIZE_EX(_ZSTR_STRUCT_SIZE(_len), 8), (use_heap)); \ GC_SET_REFCOUNT(str, 1); \ GC_TYPE_INFO(str) = GC_STRING; \ ZSTR_H(str) = 0; \ diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 8770cab3826d8..88fe13918a01e 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -1798,6 +1798,108 @@ ZEND_VM_C_LABEL(fetch_this): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +ZEND_VM_HANDLER(210, ZEND_FETCH_INNER_CLASS, CONST|TMPVAR|UNUSED, CONST, CACHE_SLOT) +{ + USE_OPLINE + SAVE_OPLINE(); + + zend_string *inner_class_name, *full_class_name; + zend_class_entry *outer_ce = NULL, *inner_ce = NULL, *scope = NULL; + + scope = EX(func)->op_array.scope; + + if (OP1_TYPE == IS_CONST) { + zval *outer_class_zv = RT_CONSTANT(opline, opline->op1); + outer_ce = zend_lookup_class(Z_STR_P(outer_class_zv)); + if (!outer_ce) { + zend_error(E_ERROR, "Outer class '%s' not found for inner class %s:>%s", Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(RT_CONSTANT(opline, opline->op2))); + HANDLE_EXCEPTION(); + } + } else if (OP1_TYPE == IS_UNUSED) { + uint32_t fetch_type; + zend_class_entry *called_scope; + + fetch_type = opline->op1.num & ZEND_FETCH_CLASS_MASK; + if (UNEXPECTED(scope == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, "Cannot use \"%s\" in the global scope", + fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : + fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + if (fetch_type == ZEND_FETCH_CLASS_SELF) { + outer_ce = scope; + } else if (fetch_type == ZEND_FETCH_CLASS_PARENT) { + if (UNEXPECTED(scope->parent == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, + "Cannot use \"parent\" when current class scope has no parent"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + outer_ce = scope->parent; + } else if (fetch_type == ZEND_FETCH_CLASS_STATIC) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + called_scope = Z_OBJCE(EX(This)); + } else { + called_scope = Z_CE(EX(This)); + } + outer_ce = called_scope; + } else { + zend_throw_error(NULL, "Unknown scope resolution"); + HANDLE_EXCEPTION(); + } + } else { + outer_ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + inner_class_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + + if (UNEXPECTED(ZSTR_LEN(outer_ce->namespaced_name.name) + ZSTR_LEN(inner_class_name) + 2 > ZSTR_MAX_LEN)) { + zend_error(E_ERROR, "Class name is too long"); + HANDLE_EXCEPTION(); + } + + full_class_name = zend_string_concat3( + ZSTR_VAL(outer_ce->namespaced_name.name), ZSTR_LEN(outer_ce->namespaced_name.name), + ":>", 2, + ZSTR_VAL(inner_class_name), ZSTR_LEN(inner_class_name) + ); + + inner_ce = zend_lookup_class(full_class_name); + if (!inner_ce) { + zend_error(E_ERROR, "Inner class '%s' not found in outer class %s", ZSTR_VAL(full_class_name), ZSTR_VAL(outer_ce->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + + if (inner_ce->required_scope) { + if (inner_ce->required_scope_absolute) { + // for private classes, we check if the scope we are currently in has access + if (scope != NULL && (inner_ce->required_scope == scope || scope->lexical_scope == inner_ce->required_scope)) { + // we are in the correct scope + } else { + zend_error(E_ERROR, "Cannot access private inner class '%s'", ZSTR_VAL(full_class_name)); + HANDLE_EXCEPTION(); + } + } else { + // for protected classes, we check if the scope is an instance of the required scope + if (scope != NULL && (instanceof_function(scope, inner_ce->required_scope) || instanceof_function(scope->lexical_scope, inner_ce->required_scope))) { + // we are in the correct scope + } else { + zend_error(E_ERROR, "Cannot access protected inner class '%s'", ZSTR_VAL(full_class_name)); + HANDLE_EXCEPTION(); + } + } + } + + Z_CE_P(EX_VAR(opline->result.var)) = inner_ce; + + zend_string_release(full_class_name); + + ZEND_VM_NEXT_OPCODE(); +} + ZEND_VM_HANDLER(80, ZEND_FETCH_R, CONST|TMPVAR|CV, UNUSED, VAR_FETCH) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper, type, BP_VAR_R); @@ -3783,7 +3885,7 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -4427,6 +4529,24 @@ ZEND_VM_COLD_CONST_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV } SAVE_OPLINE(); + + if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) { + if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) { + zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } else { + zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) { + zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } + } + if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) { zend_verify_return_error(EX(func), retval_ptr); HANDLE_EXCEPTION(); @@ -4770,7 +4890,7 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, JMP_ADDR, LAST_CATCH|CACHE_SLOT) #ifdef HAVE_DTRACE if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) { - DTRACE_EXCEPTION_CAUGHT((char *)ce->name); + DTRACE_EXCEPTION_CAUGHT((char *)ce->namespaced_name.name); } #endif /* HAVE_DTRACE */ @@ -5298,7 +5418,7 @@ ZEND_VM_C_LABEL(send_again): FREE_OP1(); if (!EG(exception)) { zend_throw_exception_ex( - NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name) + NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->namespaced_name.name) ); } HANDLE_EXCEPTION(); @@ -5357,7 +5477,7 @@ ZEND_VM_C_LABEL(send_again): zend_error( E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()" " by unpacking a Traversable, passing by-value instead", arg_num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", + EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->namespaced_name.name) : "", EX(call)->func->common.scope ? "::" : "", ZSTR_VAL(EX(call)->func->common.function_name) ); @@ -5383,7 +5503,7 @@ ZEND_VM_C_LABEL(send_again): zend_error( E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()" " by unpacking a Traversable, passing by-value instead", arg_num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", + EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->namespaced_name.name) : "", EX(call)->func->common.scope ? "::" : "", ZSTR_VAL(EX(call)->func->common.function_name) ); @@ -5980,7 +6100,7 @@ ZEND_VM_COLD_CONST_HANDLER(110, ZEND_CLONE, CONST|TMPVAR|UNUSED|THIS|CV, ANY) clone = ce->clone; clone_call = zobj->handlers->clone_obj; if (UNEXPECTED(clone_call == NULL)) { - zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->namespaced_name.name)); FREE_OP1(); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); @@ -6077,7 +6197,7 @@ ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR|CONST|UNUSED|CLASS_FETCH, CO constant_name = Z_STR_P(constant_zv); /* Magic 'class' for constant OP2 is caught at compile-time */ if (OP2_TYPE != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->namespaced_name.name); FREE_OP2(); ZEND_VM_NEXT_OPCODE(); } @@ -6089,14 +6209,14 @@ ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR|CONST|UNUSED|CLASS_FETCH, CO c = Z_PTR_P(zv); scope = EX(func)->op_array.scope; if (!zend_verify_const_access(c, scope)) { - zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name.name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP2(); HANDLE_EXCEPTION(); } if (ce->ce_flags & ZEND_ACC_TRAIT) { - zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name.name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP2(); HANDLE_EXCEPTION(); @@ -6134,7 +6254,7 @@ ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR|CONST|UNUSED|CLASS_FETCH, CO } } else { zend_throw_error(NULL, "Undefined constant %s::%s", - ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name.name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP2(); HANDLE_EXCEPTION(); @@ -6302,7 +6422,7 @@ ZEND_VM_C_LABEL(add_unpack_again): FREE_OP1(); if (!EG(exception)) { zend_throw_exception_ex( - NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name) + NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->namespaced_name.name) ); } HANDLE_EXCEPTION(); @@ -7284,7 +7404,7 @@ ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR) if (UNEXPECTED(prop_info->flags & ZEND_ACC_READONLY)) { zend_throw_error(NULL, "Cannot acquire reference to readonly property %s::$%s", - ZSTR_VAL(prop_info->ce->name), ZSTR_VAL(p->key)); + ZSTR_VAL(prop_info->ce->namespaced_name.name), ZSTR_VAL(p->key)); UNDEF_RESULT(); HANDLE_EXCEPTION(); } @@ -8173,6 +8293,7 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) case ZEND_FETCH_CLASS: case ZEND_DECLARE_ANON_CLASS: + case ZEND_FETCH_INNER_CLASS: break; /* return value is zend_class_entry pointer */ default: @@ -8483,7 +8604,7 @@ ZEND_VM_C_LABEL(yield_from_try_again): if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) { if (!EG(exception)) { - zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->namespaced_name.name)); } UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -8817,7 +8938,7 @@ ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, CV|TMPVAR|UNUSED|CLASS_FETCH, ANY) } } - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->namespaced_name.name); FREE_OP1(); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -8835,7 +8956,7 @@ ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, CV|TMPVAR|UNUSED|CLASS_FETCH, ANY) switch (fetch_type) { case ZEND_FETCH_CLASS_SELF: - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->namespaced_name.name); break; case ZEND_FETCH_CLASS_PARENT: if (UNEXPECTED(scope->parent == NULL)) { @@ -8845,7 +8966,7 @@ ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, CV|TMPVAR|UNUSED|CLASS_FETCH, ANY) ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->namespaced_name.name); break; case ZEND_FETCH_CLASS_STATIC: if (Z_TYPE(EX(This)) == IS_OBJECT) { @@ -8853,7 +8974,7 @@ ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, CV|TMPVAR|UNUSED|CLASS_FETCH, ANY) } else { called_scope = Z_CE(EX(This)); } - ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->namespaced_name.name); break; EMPTY_SWITCH_DEFAULT_CASE() } @@ -9464,7 +9585,7 @@ ZEND_VM_COLD_CONST_HANDLER(191, ZEND_GET_CLASS, UNUSED|CONST|TMPVAR|CV, UNUSED) HANDLE_EXCEPTION(); } else { zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated"); - ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->namespaced_name.name); if (UNEXPECTED(EG(exception))) { HANDLE_EXCEPTION(); } @@ -9477,7 +9598,7 @@ ZEND_VM_COLD_CONST_HANDLER(191, ZEND_GET_CLASS, UNUSED|CONST|TMPVAR|CV, UNUSED) op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); while (1) { if (Z_TYPE_P(op1) == IS_OBJECT) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->namespaced_name.name); } else if ((OP1_TYPE & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { op1 = Z_REFVAL_P(op1); continue; @@ -9500,9 +9621,9 @@ ZEND_VM_HANDLER(192, ZEND_GET_CALLED_CLASS, UNUSED, UNUSED) USE_OPLINE if (Z_TYPE(EX(This)) == IS_OBJECT) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->namespaced_name.name); } else if (Z_CE(EX(This))) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->namespaced_name.name); } else { ZEND_ASSERT(!EX(func)->common.scope); SAVE_OPLINE(); @@ -9806,12 +9927,12 @@ ZEND_VM_HANDLER(209, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL, CONST, UNUSED|NUM, NUM zend_property_info *prop_info = zend_hash_find_ptr(&parent_ce->properties_info, property_name); if (!prop_info) { - zend_throw_error(NULL, "Undefined property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name)); + zend_throw_error(NULL, "Undefined property %s::$%s", ZSTR_VAL(parent_ce->namespaced_name.name), ZSTR_VAL(property_name.name)); UNDEF_RESULT(); HANDLE_EXCEPTION(); } if (prop_info->flags & ZEND_ACC_PRIVATE) { - zend_throw_error(NULL, "Cannot access private property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name)); + zend_throw_error(NULL, "Cannot access private property %s::$%s", ZSTR_VAL(parent_ce->namespaced_name.name), ZSTR_VAL(property_name.name)); UNDEF_RESULT(); HANDLE_EXCEPTION(); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index e890f94cb08e2..f5d0a7ff72aa1 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2391,7 +2391,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_ FREE_OP(opline->op1_type, opline->op1.var); if (!EG(exception)) { zend_throw_exception_ex( - NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name) + NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->namespaced_name.name) ); } HANDLE_EXCEPTION(); @@ -2450,7 +2450,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_ zend_error( E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()" " by unpacking a Traversable, passing by-value instead", arg_num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", + EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->namespaced_name.name) : "", EX(call)->func->common.scope ? "::" : "", ZSTR_VAL(EX(call)->func->common.function_name) ); @@ -2476,7 +2476,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_ zend_error( E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()" " by unpacking a Traversable, passing by-value instead", arg_num, - EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "", + EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->namespaced_name.name) : "", EX(call)->func->common.scope ? "::" : "", ZSTR_VAL(EX(call)->func->common.function_name) ); @@ -2771,7 +2771,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER( FREE_OP(opline->op1_type, opline->op1.var); if (!EG(exception)) { zend_throw_exception_ex( - NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name) + NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->namespaced_name.name) ); } HANDLE_EXCEPTION(); @@ -3310,6 +3310,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER( case ZEND_FETCH_CLASS: case ZEND_DECLARE_ANON_CLASS: + case ZEND_FETCH_INNER_CLASS: break; /* return value is zend_class_entry pointer */ default: @@ -5007,7 +5008,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_ #ifdef HAVE_DTRACE if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) { - DTRACE_EXCEPTION_CAUGHT((char *)ce->name); + DTRACE_EXCEPTION_CAUGHT((char *)ce->namespaced_name.name); } #endif /* HAVE_DTRACE */ @@ -5121,7 +5122,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_ clone = ce->clone; clone_call = zobj->handlers->clone_obj; if (UNEXPECTED(clone_call == NULL)) { - zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->namespaced_name.name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); @@ -5836,7 +5837,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CONST_HANDLER( if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) { if (!EG(exception)) { - zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->namespaced_name.name)); } UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -6610,6 +6611,108 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CON ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + SAVE_OPLINE(); + + zend_string *inner_class_name, *full_class_name; + zend_class_entry *outer_ce = NULL, *inner_ce = NULL, *scope = NULL; + + scope = EX(func)->op_array.scope; + + if (IS_CONST == IS_CONST) { + zval *outer_class_zv = RT_CONSTANT(opline, opline->op1); + outer_ce = zend_lookup_class(Z_STR_P(outer_class_zv)); + if (!outer_ce) { + zend_error(E_ERROR, "Outer class '%s' not found for inner class %s:>%s", Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(RT_CONSTANT(opline, opline->op2))); + HANDLE_EXCEPTION(); + } + } else if (IS_CONST == IS_UNUSED) { + uint32_t fetch_type; + zend_class_entry *called_scope; + + fetch_type = opline->op1.num & ZEND_FETCH_CLASS_MASK; + if (UNEXPECTED(scope == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, "Cannot use \"%s\" in the global scope", + fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : + fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + if (fetch_type == ZEND_FETCH_CLASS_SELF) { + outer_ce = scope; + } else if (fetch_type == ZEND_FETCH_CLASS_PARENT) { + if (UNEXPECTED(scope->parent == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, + "Cannot use \"parent\" when current class scope has no parent"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + outer_ce = scope->parent; + } else if (fetch_type == ZEND_FETCH_CLASS_STATIC) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + called_scope = Z_OBJCE(EX(This)); + } else { + called_scope = Z_CE(EX(This)); + } + outer_ce = called_scope; + } else { + zend_throw_error(NULL, "Unknown scope resolution"); + HANDLE_EXCEPTION(); + } + } else { + outer_ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + inner_class_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + + if (UNEXPECTED(ZSTR_LEN(outer_ce->namespaced_name.name) + ZSTR_LEN(inner_class_name) + 2 > ZSTR_MAX_LEN)) { + zend_error(E_ERROR, "Class name is too long"); + HANDLE_EXCEPTION(); + } + + full_class_name = zend_string_concat3( + ZSTR_VAL(outer_ce->namespaced_name.name), ZSTR_LEN(outer_ce->namespaced_name.name), + ":>", 2, + ZSTR_VAL(inner_class_name), ZSTR_LEN(inner_class_name) + ); + + inner_ce = zend_lookup_class(full_class_name); + if (!inner_ce) { + zend_error(E_ERROR, "Inner class '%s' not found in outer class %s", ZSTR_VAL(full_class_name), ZSTR_VAL(outer_ce->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + + if (inner_ce->required_scope) { + if (inner_ce->required_scope_absolute) { + // for private classes, we check if the scope we are currently in has access + if (scope != NULL && (inner_ce->required_scope == scope || scope->lexical_scope == inner_ce->required_scope)) { + // we are in the correct scope + } else { + zend_error(E_ERROR, "Cannot access private inner class '%s'", ZSTR_VAL(full_class_name)); + HANDLE_EXCEPTION(); + } + } else { + // for protected classes, we check if the scope is an instance of the required scope + if (scope != NULL && (instanceof_function(scope, inner_ce->required_scope) || instanceof_function(scope->lexical_scope, inner_ce->required_scope))) { + // we are in the correct scope + } else { + zend_error(E_ERROR, "Cannot access protected inner class '%s'", ZSTR_VAL(full_class_name)); + HANDLE_EXCEPTION(); + } + } + } + + Z_CE_P(EX_VAR(opline->result.var)) = inner_ce; + + zend_string_release(full_class_name); + + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -7369,7 +7472,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -7600,7 +7703,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS constant_name = Z_STR_P(constant_zv); /* Magic 'class' for constant OP2 is caught at compile-time */ if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->namespaced_name.name); ZEND_VM_NEXT_OPCODE(); } @@ -7612,14 +7715,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS c = Z_PTR_P(zv); scope = EX(func)->op_array.scope; if (!zend_verify_const_access(c, scope)) { - zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } if (ce->ce_flags & ZEND_ACC_TRAIT) { - zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); @@ -7657,7 +7760,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS } } else { zend_throw_error(NULL, "Undefined constant %s::%s", - ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); @@ -8760,7 +8863,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS constant_name = Z_STR_P(constant_zv); /* Magic 'class' for constant OP2 is caught at compile-time */ if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->namespaced_name.name); FREE_OP(opline->op2_type, opline->op2.var); ZEND_VM_NEXT_OPCODE(); } @@ -8772,14 +8875,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS c = Z_PTR_P(zv); scope = EX(func)->op_array.scope; if (!zend_verify_const_access(c, scope)) { - zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP(opline->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } if (ce->ce_flags & ZEND_ACC_TRAIT) { - zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP(opline->op2_type, opline->op2.var); HANDLE_EXCEPTION(); @@ -8817,7 +8920,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS } } else { zend_throw_error(NULL, "Undefined constant %s::%s", - ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP(opline->op2_type, opline->op2.var); HANDLE_EXCEPTION(); @@ -9943,7 +10046,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -10701,7 +10804,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -10799,6 +10902,24 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYP } SAVE_OPLINE(); + + if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) { + if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) { + zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } else { + zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) { + zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } + } + if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) { zend_verify_return_error(EX(func), retval_ptr); HANDLE_EXCEPTION(); @@ -11375,7 +11496,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CO HANDLE_EXCEPTION(); } else { zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated"); - ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->namespaced_name.name); if (UNEXPECTED(EG(exception))) { HANDLE_EXCEPTION(); } @@ -11388,7 +11509,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CO op1 = RT_CONSTANT(opline, opline->op1); while (1) { if (Z_TYPE_P(op1) == IS_OBJECT) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->namespaced_name.name); } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { op1 = Z_REFVAL_P(op1); continue; @@ -11521,12 +11642,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_PARENT_PROPERTY_HOOK_CALL zend_property_info *prop_info = zend_hash_find_ptr(&parent_ce->properties_info, property_name); if (!prop_info) { - zend_throw_error(NULL, "Undefined property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name)); + zend_throw_error(NULL, "Undefined property %s::$%s", ZSTR_VAL(parent_ce->namespaced_name.name), ZSTR_VAL(property_name)); UNDEF_RESULT(); HANDLE_EXCEPTION(); } if (prop_info->flags & ZEND_ACC_PRIVATE) { - zend_throw_error(NULL, "Cannot access private property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name)); + zend_throw_error(NULL, "Cannot access private property %s::$%s", ZSTR_VAL(parent_ce->namespaced_name.name), ZSTR_VAL(property_name)); UNDEF_RESULT(); HANDLE_EXCEPTION(); } @@ -12435,7 +12556,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -15276,7 +15397,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND clone = ce->clone; clone_call = zobj->handlers->clone_obj; if (UNEXPECTED(clone_call == NULL)) { - zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->namespaced_name.name)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); @@ -15442,7 +15563,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) { if (!EG(exception)) { - zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->namespaced_name.name)); } UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -15603,7 +15724,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_H } } - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->namespaced_name.name); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -15621,7 +15742,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_H switch (fetch_type) { case ZEND_FETCH_CLASS_SELF: - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->namespaced_name.name); break; case ZEND_FETCH_CLASS_PARENT: if (UNEXPECTED(scope->parent == NULL)) { @@ -15631,7 +15752,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_H ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->namespaced_name.name); break; case ZEND_FETCH_CLASS_STATIC: if (Z_TYPE(EX(This)) == IS_OBJECT) { @@ -15639,7 +15760,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_H } else { called_scope = Z_CE(EX(This)); } - ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->namespaced_name.name); break; EMPTY_SWITCH_DEFAULT_CASE() } @@ -16127,6 +16248,108 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HAN ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + SAVE_OPLINE(); + + zend_string *inner_class_name, *full_class_name; + zend_class_entry *outer_ce = NULL, *inner_ce = NULL, *scope = NULL; + + scope = EX(func)->op_array.scope; + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + zval *outer_class_zv = RT_CONSTANT(opline, opline->op1); + outer_ce = zend_lookup_class(Z_STR_P(outer_class_zv)); + if (!outer_ce) { + zend_error(E_ERROR, "Outer class '%s' not found for inner class %s:>%s", Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(RT_CONSTANT(opline, opline->op2))); + HANDLE_EXCEPTION(); + } + } else if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + uint32_t fetch_type; + zend_class_entry *called_scope; + + fetch_type = opline->op1.num & ZEND_FETCH_CLASS_MASK; + if (UNEXPECTED(scope == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, "Cannot use \"%s\" in the global scope", + fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : + fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + if (fetch_type == ZEND_FETCH_CLASS_SELF) { + outer_ce = scope; + } else if (fetch_type == ZEND_FETCH_CLASS_PARENT) { + if (UNEXPECTED(scope->parent == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, + "Cannot use \"parent\" when current class scope has no parent"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + outer_ce = scope->parent; + } else if (fetch_type == ZEND_FETCH_CLASS_STATIC) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + called_scope = Z_OBJCE(EX(This)); + } else { + called_scope = Z_CE(EX(This)); + } + outer_ce = called_scope; + } else { + zend_throw_error(NULL, "Unknown scope resolution"); + HANDLE_EXCEPTION(); + } + } else { + outer_ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + inner_class_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + + if (UNEXPECTED(ZSTR_LEN(outer_ce->namespaced_name.name) + ZSTR_LEN(inner_class_name) + 2 > ZSTR_MAX_LEN)) { + zend_error(E_ERROR, "Class name is too long"); + HANDLE_EXCEPTION(); + } + + full_class_name = zend_string_concat3( + ZSTR_VAL(outer_ce->namespaced_name.name), ZSTR_LEN(outer_ce->namespaced_name.name), + ":>", 2, + ZSTR_VAL(inner_class_name), ZSTR_LEN(inner_class_name) + ); + + inner_ce = zend_lookup_class(full_class_name); + if (!inner_ce) { + zend_error(E_ERROR, "Inner class '%s' not found in outer class %s", ZSTR_VAL(full_class_name), ZSTR_VAL(outer_ce->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + + if (inner_ce->required_scope) { + if (inner_ce->required_scope_absolute) { + // for private classes, we check if the scope we are currently in has access + if (scope != NULL && (inner_ce->required_scope == scope || scope->lexical_scope == inner_ce->required_scope)) { + // we are in the correct scope + } else { + zend_error(E_ERROR, "Cannot access private inner class '%s'", ZSTR_VAL(full_class_name)); + HANDLE_EXCEPTION(); + } + } else { + // for protected classes, we check if the scope is an instance of the required scope + if (scope != NULL && (instanceof_function(scope, inner_ce->required_scope) || instanceof_function(scope->lexical_scope, inner_ce->required_scope))) { + // we are in the correct scope + } else { + zend_error(E_ERROR, "Cannot access protected inner class '%s'", ZSTR_VAL(full_class_name)); + HANDLE_EXCEPTION(); + } + } + } + + Z_CE_P(EX_VAR(opline->result.var)) = inner_ce; + + zend_string_release(full_class_name); + + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -18868,7 +19091,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_H HANDLE_EXCEPTION(); } else { zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated"); - ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->namespaced_name.name); if (UNEXPECTED(EG(exception))) { HANDLE_EXCEPTION(); } @@ -18881,7 +19104,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_H op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); while (1) { if (Z_TYPE_P(op1) == IS_OBJECT) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->namespaced_name.name); } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { op1 = Z_REFVAL_P(op1); continue; @@ -21536,6 +21759,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UN } SAVE_OPLINE(); + + if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) { + if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) { + zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } else { + zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) { + zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } + } + if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) { zend_verify_return_error(EX(func), retval_ptr); HANDLE_EXCEPTION(); @@ -23170,7 +23411,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(Z if (UNEXPECTED(prop_info->flags & ZEND_ACC_READONLY)) { zend_throw_error(NULL, "Cannot acquire reference to readonly property %s::$%s", - ZSTR_VAL(prop_info->ce->name), ZSTR_VAL(p->key)); + ZSTR_VAL(prop_info->ce->namespaced_name.name), ZSTR_VAL(p->key)); UNDEF_RESULT(); HANDLE_EXCEPTION(); } @@ -25471,7 +25712,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -25859,7 +26100,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ constant_name = Z_STR_P(constant_zv); /* Magic 'class' for constant OP2 is caught at compile-time */ if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->namespaced_name.name); ZEND_VM_NEXT_OPCODE(); } @@ -25871,14 +26112,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ c = Z_PTR_P(zv); scope = EX(func)->op_array.scope; if (!zend_verify_const_access(c, scope)) { - zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } if (ce->ce_flags & ZEND_ACC_TRAIT) { - zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); @@ -25916,7 +26157,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ } } else { zend_throw_error(NULL, "Undefined constant %s::%s", - ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); @@ -26428,7 +26669,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ constant_name = Z_STR_P(constant_zv); /* Magic 'class' for constant OP2 is caught at compile-time */ if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->namespaced_name.name); FREE_OP(opline->op2_type, opline->op2.var); ZEND_VM_NEXT_OPCODE(); } @@ -26440,14 +26681,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ c = Z_PTR_P(zv); scope = EX(func)->op_array.scope; if (!zend_verify_const_access(c, scope)) { - zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP(opline->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } if (ce->ce_flags & ZEND_ACC_TRAIT) { - zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP(opline->op2_type, opline->op2.var); HANDLE_EXCEPTION(); @@ -26485,7 +26726,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ } } else { zend_throw_error(NULL, "Undefined constant %s::%s", - ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP(opline->op2_type, opline->op2.var); HANDLE_EXCEPTION(); @@ -28404,7 +28645,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -29914,7 +30155,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -30012,6 +30253,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UN } SAVE_OPLINE(); + + if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) { + if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) { + zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } else { + zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) { + zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } + } + if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) { zend_verify_return_error(EX(func), retval_ptr); HANDLE_EXCEPTION(); @@ -32853,7 +33112,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -33439,7 +33698,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND clone = ce->clone; clone_call = zobj->handlers->clone_obj; if (UNEXPECTED(clone_call == NULL)) { - zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->namespaced_name.name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); @@ -33482,7 +33741,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_H } } - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->namespaced_name.name); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -33500,7 +33759,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_H switch (fetch_type) { case ZEND_FETCH_CLASS_SELF: - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->namespaced_name.name); break; case ZEND_FETCH_CLASS_PARENT: if (UNEXPECTED(scope->parent == NULL)) { @@ -33510,7 +33769,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_H ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->namespaced_name.name); break; case ZEND_FETCH_CLASS_STATIC: if (Z_TYPE(EX(This)) == IS_OBJECT) { @@ -33518,7 +33777,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_H } else { called_scope = Z_CE(EX(This)); } - ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->namespaced_name.name); break; EMPTY_SWITCH_DEFAULT_CASE() } @@ -33744,6 +34003,108 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + SAVE_OPLINE(); + + zend_string *inner_class_name, *full_class_name; + zend_class_entry *outer_ce = NULL, *inner_ce = NULL, *scope = NULL; + + scope = EX(func)->op_array.scope; + + if (IS_UNUSED == IS_CONST) { + zval *outer_class_zv = RT_CONSTANT(opline, opline->op1); + outer_ce = zend_lookup_class(Z_STR_P(outer_class_zv)); + if (!outer_ce) { + zend_error(E_ERROR, "Outer class '%s' not found for inner class %s:>%s", Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(RT_CONSTANT(opline, opline->op2))); + HANDLE_EXCEPTION(); + } + } else if (IS_UNUSED == IS_UNUSED) { + uint32_t fetch_type; + zend_class_entry *called_scope; + + fetch_type = opline->op1.num & ZEND_FETCH_CLASS_MASK; + if (UNEXPECTED(scope == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, "Cannot use \"%s\" in the global scope", + fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : + fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + if (fetch_type == ZEND_FETCH_CLASS_SELF) { + outer_ce = scope; + } else if (fetch_type == ZEND_FETCH_CLASS_PARENT) { + if (UNEXPECTED(scope->parent == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, + "Cannot use \"parent\" when current class scope has no parent"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + outer_ce = scope->parent; + } else if (fetch_type == ZEND_FETCH_CLASS_STATIC) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + called_scope = Z_OBJCE(EX(This)); + } else { + called_scope = Z_CE(EX(This)); + } + outer_ce = called_scope; + } else { + zend_throw_error(NULL, "Unknown scope resolution"); + HANDLE_EXCEPTION(); + } + } else { + outer_ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + inner_class_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + + if (UNEXPECTED(ZSTR_LEN(outer_ce->namespaced_name.name) + ZSTR_LEN(inner_class_name) + 2 > ZSTR_MAX_LEN)) { + zend_error(E_ERROR, "Class name is too long"); + HANDLE_EXCEPTION(); + } + + full_class_name = zend_string_concat3( + ZSTR_VAL(outer_ce->namespaced_name.name), ZSTR_LEN(outer_ce->namespaced_name.name), + ":>", 2, + ZSTR_VAL(inner_class_name), ZSTR_LEN(inner_class_name) + ); + + inner_ce = zend_lookup_class(full_class_name); + if (!inner_ce) { + zend_error(E_ERROR, "Inner class '%s' not found in outer class %s", ZSTR_VAL(full_class_name), ZSTR_VAL(outer_ce->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + + if (inner_ce->required_scope) { + if (inner_ce->required_scope_absolute) { + // for private classes, we check if the scope we are currently in has access + if (scope != NULL && (inner_ce->required_scope == scope || scope->lexical_scope == inner_ce->required_scope)) { + // we are in the correct scope + } else { + zend_error(E_ERROR, "Cannot access private inner class '%s'", ZSTR_VAL(full_class_name)); + HANDLE_EXCEPTION(); + } + } else { + // for protected classes, we check if the scope is an instance of the required scope + if (scope != NULL && (instanceof_function(scope, inner_ce->required_scope) || instanceof_function(scope->lexical_scope, inner_ce->required_scope))) { + // we are in the correct scope + } else { + zend_error(E_ERROR, "Cannot access protected inner class '%s'", ZSTR_VAL(full_class_name)); + HANDLE_EXCEPTION(); + } + } + } + + Z_CE_P(EX_VAR(opline->result.var)) = inner_ce; + + zend_string_release(full_class_name); + + ZEND_VM_NEXT_OPCODE(); +} + static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -35124,7 +35485,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -35267,7 +35628,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS constant_name = Z_STR_P(constant_zv); /* Magic 'class' for constant OP2 is caught at compile-time */ if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->namespaced_name.name); ZEND_VM_NEXT_OPCODE(); } @@ -35279,14 +35640,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS c = Z_PTR_P(zv); scope = EX(func)->op_array.scope; if (!zend_verify_const_access(c, scope)) { - zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } if (ce->ce_flags & ZEND_ACC_TRAIT) { - zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); @@ -35324,7 +35685,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS } } else { zend_throw_error(NULL, "Undefined constant %s::%s", - ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); @@ -35626,7 +35987,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS constant_name = Z_STR_P(constant_zv); /* Magic 'class' for constant OP2 is caught at compile-time */ if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->namespaced_name.name); FREE_OP(opline->op2_type, opline->op2.var); ZEND_VM_NEXT_OPCODE(); } @@ -35638,14 +35999,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS c = Z_PTR_P(zv); scope = EX(func)->op_array.scope; if (!zend_verify_const_access(c, scope)) { - zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP(opline->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } if (ce->ce_flags & ZEND_ACC_TRAIT) { - zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP(opline->op2_type, opline->op2.var); HANDLE_EXCEPTION(); @@ -35683,7 +36044,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS } } else { zend_throw_error(NULL, "Undefined constant %s::%s", - ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); + ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); FREE_OP(opline->op2_type, opline->op2.var); HANDLE_EXCEPTION(); @@ -37293,7 +37654,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -37704,7 +38065,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -37802,6 +38163,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED } SAVE_OPLINE(); + + if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) { + if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) { + zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } else { + zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) { + zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } + } + if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) { zend_verify_return_error(EX(func), retval_ptr); HANDLE_EXCEPTION(); @@ -38152,7 +38531,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_H HANDLE_EXCEPTION(); } else { zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated"); - ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->namespaced_name.name); if (UNEXPECTED(EG(exception))) { HANDLE_EXCEPTION(); } @@ -38165,7 +38544,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_H op1 = NULL; while (1) { if (Z_TYPE_P(op1) == IS_OBJECT) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->namespaced_name.name); } else if ((IS_UNUSED & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { op1 = Z_REFVAL_P(op1); continue; @@ -38188,9 +38567,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CALLED_CLASS_SPEC_UNUSED_U USE_OPLINE if (Z_TYPE(EX(This)) == IS_OBJECT) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->namespaced_name.name); } else if (Z_CE(EX(This))) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->namespaced_name.name); } else { ZEND_ASSERT(!EX(func)->common.scope); SAVE_OPLINE(); @@ -39938,7 +40317,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U HANDLE_EXCEPTION(); } if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->namespaced_name.name)); HANDLE_EXCEPTION(); } fbc = ce->constructor; @@ -40941,7 +41320,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPC clone = ce->clone; clone_call = zobj->handlers->clone_obj; if (UNEXPECTED(clone_call == NULL)) { - zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->namespaced_name.name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); @@ -41537,7 +41916,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEN if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) { if (!EG(exception)) { - zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->namespaced_name.name)); } UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -41698,7 +42077,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDL } } - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->namespaced_name.name); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -41716,7 +42095,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDL switch (fetch_type) { case ZEND_FETCH_CLASS_SELF: - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->namespaced_name.name); break; case ZEND_FETCH_CLASS_PARENT: if (UNEXPECTED(scope->parent == NULL)) { @@ -41726,7 +42105,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDL ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->namespaced_name.name); break; case ZEND_FETCH_CLASS_STATIC: if (Z_TYPE(EX(This)) == IS_OBJECT) { @@ -41734,7 +42113,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDL } else { called_scope = Z_CE(EX(This)); } - ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->namespaced_name.name); break; EMPTY_SWITCH_DEFAULT_CASE() } @@ -50603,6 +50982,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNU } SAVE_OPLINE(); + + if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) { + if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) { + zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } else { + zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) { + if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) { + zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->namespaced_name.name)); + HANDLE_EXCEPTION(); + } + } + } + if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) { zend_verify_return_error(EX(func), retval_ptr); HANDLE_EXCEPTION(); @@ -51371,7 +51768,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDL HANDLE_EXCEPTION(); } else { zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated"); - ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->namespaced_name.name); if (UNEXPECTED(EG(exception))) { HANDLE_EXCEPTION(); } @@ -51384,7 +51781,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDL op1 = EX_VAR(opline->op1.var); while (1) { if (Z_TYPE_P(op1) == IS_OBJECT) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name); + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->namespaced_name.name); } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { op1 = Z_REFVAL_P(op1); continue; @@ -57643,6 +58040,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_LABEL, (void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL, (void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -59514,6 +59916,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CONST_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST): + VM_TRACE(ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST) + ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST): VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST) ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60784,6 +61191,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST) + ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST): VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62372,6 +62784,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST): + VM_TRACE(ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST) + ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST): VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -66830,6 +67247,11 @@ void zend_vm_init(void) ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER, ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER, + ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST_HANDLER, + ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_HANDLER, + ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_HANDLER, + ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST_HANDLER, + ZEND_NULL_HANDLER, ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -67787,7 +68209,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3486, + 3491, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -67821,7 +68243,7 @@ void zend_vm_init(void) 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1584 | SPEC_RULE_OP1, 1589, - 3486, + 3491, 1590 | SPEC_RULE_OP1, 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2, @@ -67952,52 +68374,52 @@ void zend_vm_init(void) 2573 | SPEC_RULE_OBSERVER, 2575, 2576, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, - 3486, + 2577 | SPEC_RULE_OP1, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, + 3491, }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -68170,7 +68592,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2585 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2590 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -68178,7 +68600,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2610 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2615 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -68186,7 +68608,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2635 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2640 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -68197,17 +68619,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2660 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2665 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2685 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2690 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2710 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2715 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -68218,17 +68640,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2735 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2740 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2760 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2765 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2785 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2790 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -68239,14 +68661,14 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2810 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2815 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2890 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3110 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3115 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -68257,14 +68679,14 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2965 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3040 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3115 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3120 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -68275,12 +68697,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2810 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2815 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2890 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -68291,12 +68713,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2965 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3040 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -68304,12 +68726,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3120 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3125 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3195 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3200 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -68317,79 +68739,79 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3270 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3275 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3345 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3350 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3432 | SPEC_RULE_OP1; - } else if (op1_info == MAY_BE_DOUBLE) { spec = 3437 | SPEC_RULE_OP1; - } else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) { + } else if (op1_info == MAY_BE_DOUBLE) { spec = 3442 | SPEC_RULE_OP1; + } else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) { + spec = 3447 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3420 | SPEC_RULE_RETVAL; + spec = 3425 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3422 | SPEC_RULE_RETVAL; + spec = 3427 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3424 | SPEC_RULE_RETVAL; + spec = 3429 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3426 | SPEC_RULE_RETVAL; + spec = 3431 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3428; + spec = 3433; } else if (op1_info == MAY_BE_LONG) { - spec = 3429; + spec = 3434; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3430; + spec = 3435; } else if (op1_info == MAY_BE_LONG) { - spec = 3431; + spec = 3436; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2584; + spec = 2589; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2577; + spec = 2582; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2578; + spec = 2583; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3482; + spec = 3487; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3477 | SPEC_RULE_OP1; + spec = 3482 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 3484 | SPEC_RULE_RETVAL; + spec = 3489 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -68397,22 +68819,22 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3447 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3452 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3483; + spec = 3488; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3472 | SPEC_RULE_OP1; + spec = 3477 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2579 | SPEC_RULE_OP1; + spec = 2584 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: @@ -68479,4 +68901,3 @@ ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data* ex) #endif return ret; } - diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 7f3a3cb5de260..e632a82498637 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1372,502 +1372,506 @@ _(2574, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \ _(2575, ZEND_JMP_FRAMELESS_SPEC_CONST) \ _(2576, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ - _(2577, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2578, ZEND_RECV_NOTYPE_SPEC) \ - _(2580, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ - _(2581, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ - _(2583, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ - _(2584, ZEND_JMP_FORWARD_SPEC) \ - _(2590, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2592, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2594, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2577, ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST) \ + _(2578, ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST) \ + _(2579, ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST) \ + _(2580, ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST) \ + _(2582, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ + _(2583, ZEND_RECV_NOTYPE_SPEC) \ + _(2585, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ + _(2586, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ + _(2588, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ + _(2589, ZEND_JMP_FORWARD_SPEC) \ _(2595, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2596, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2599, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2605, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2606, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2607, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2609, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2615, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2617, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2619, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2600, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2601, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2602, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2604, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2610, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2611, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2612, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2614, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2620, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2621, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2624, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2630, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2631, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2632, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2634, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2640, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2642, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2644, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2625, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2626, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2627, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2629, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2635, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2636, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2637, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2639, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2645, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2646, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2649, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2655, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2656, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2657, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2659, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2661, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2664, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2665, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2669, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2650, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2651, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2652, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2654, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2660, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2661, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2662, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2664, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2669, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ _(2670, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2671, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2674, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2680, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2681, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2682, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2684, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2686, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2687, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2689, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2690, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2692, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2694, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2675, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2677, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2679, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2685, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2686, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2687, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2689, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2691, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2692, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2694, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ _(2695, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2696, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2699, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2705, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2706, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2707, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2709, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2711, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2712, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2714, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2715, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2717, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2719, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2700, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2701, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2702, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2704, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2710, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2711, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2712, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2714, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2716, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2717, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2719, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ _(2720, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2721, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2724, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2730, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2731, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2732, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2734, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2740, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2742, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2744, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2725, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2726, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2727, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2729, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2735, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2736, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2737, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2739, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2745, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2746, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2749, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2755, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2756, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2757, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2759, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2765, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2767, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2769, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2750, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2751, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2752, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2754, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2760, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2761, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2762, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2764, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2770, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2771, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2774, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2780, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2781, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2782, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2784, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2790, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2792, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2794, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2775, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2776, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2777, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2779, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2785, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2786, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2787, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2789, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2795, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2796, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2799, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2805, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2806, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2807, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2809, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3110, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3114, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3115, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3119, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3125, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3126, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3127, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3128, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3134, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3420, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3421, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3422, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3423, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3424, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3425, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3426, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3427, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3428, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3429, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3430, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3431, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3432, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3433, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3434, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3436, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3437, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3438, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3439, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3441, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3442, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3443, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3444, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3446, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3448, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3451, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3453, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(2800, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2801, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2802, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2804, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2810, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2811, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2812, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2814, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2851, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2880, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2881, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2887, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2888, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2889, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2926, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2955, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2956, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2962, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2963, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2964, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3001, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3030, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3031, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3037, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3038, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3039, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3076, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3105, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3106, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3112, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3113, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3114, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3115, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3119, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3120, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3124, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3128, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3129, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3130, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3131, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3137, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3138, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3139, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3167, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3197, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3198, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3199, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3242, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3272, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3273, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3274, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3317, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3347, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3349, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3392, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3422, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3423, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3424, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3425, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3426, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3427, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3428, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3429, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3430, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3431, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3432, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3433, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3434, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3435, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3436, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3437, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3438, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3439, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3441, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3442, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3443, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3444, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3446, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3447, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3448, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3449, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3451, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3453, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3458, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3461, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3468, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3471, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3474, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3476, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3479, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3481, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3482, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3483, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3484, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3485, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3485+1, ZEND_NULL) + _(3462, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3463, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3464, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3472, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3473, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3474, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3479, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3481, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3484, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3486, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3487, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3488, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3489, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3490, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3490+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 202dfd3f734f3..b1e6c2950fd6d 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -22,7 +22,7 @@ #include #include -static const char *zend_vm_opcodes_names[210] = { +static const char *zend_vm_opcodes_names[211] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -233,9 +233,10 @@ static const char *zend_vm_opcodes_names[210] = { "ZEND_FRAMELESS_ICALL_3", "ZEND_JMP_FRAMELESS", "ZEND_INIT_PARENT_PROPERTY_HOOK_CALL", + "ZEND_FETCH_INNER_CLASS", }; -static uint32_t zend_vm_opcodes_flags[210] = { +static uint32_t zend_vm_opcodes_flags[211] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -446,6 +447,7 @@ static uint32_t zend_vm_opcodes_flags[210] = { 0x00000000, 0x01042003, 0x01001103, + 0x00040307, }; ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(uint8_t opcode) { diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index d472b5b9660f5..9734d26ee768e 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -291,7 +291,8 @@ END_EXTERN_C() #define ZEND_FRAMELESS_ICALL_3 207 #define ZEND_JMP_FRAMELESS 208 #define ZEND_INIT_PARENT_PROPERTY_HOOK_CALL 209 +#define ZEND_FETCH_INNER_CLASS 210 -#define ZEND_VM_LAST_OPCODE 209 +#define ZEND_VM_LAST_OPCODE 210 #endif diff --git a/Zend/zend_weakrefs.c b/Zend/zend_weakrefs.c index cf363cd12595c..e5a4643caf76f 100644 --- a/Zend/zend_weakrefs.c +++ b/Zend/zend_weakrefs.c @@ -367,7 +367,7 @@ static zval *zend_weakmap_read_dimension(zend_object *object, zval *offset, int if (zv == NULL) { if (type != BP_VAR_IS) { zend_throw_error(NULL, - "Object %s#%d not contained in WeakMap", ZSTR_VAL(obj_addr->ce->name), obj_addr->handle); + "Object %s#%d not contained in WeakMap", ZSTR_VAL(obj_addr->ce->namespaced_name.name), obj_addr->handle); return NULL; } return NULL; @@ -802,4 +802,3 @@ void zend_register_weakref_ce(void) /* {{{ */ zend_weakmap_handlers.clone_obj = zend_weakmap_clone_obj; } /* }}} */ - diff --git a/Zend/zend_weakrefs_arginfo.h b/Zend/zend_weakrefs_arginfo.h index eba02f03fb13c..6524d1587c86c 100644 --- a/Zend/zend_weakrefs_arginfo.h +++ b/Zend/zend_weakrefs_arginfo.h @@ -64,8 +64,10 @@ static const zend_function_entry class_WeakMap_methods[] = { static zend_class_entry *register_class_WeakReference(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "WeakReference", class_WeakReference_methods); + INIT_CLASS_NAME(namespaced_name, "WeakReference"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_WeakReference_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -74,8 +76,10 @@ static zend_class_entry *register_class_WeakReference(void) static zend_class_entry *register_class_WeakMap(zend_class_entry *class_entry_ArrayAccess, zend_class_entry *class_entry_Countable, zend_class_entry *class_entry_IteratorAggregate) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "WeakMap", class_WeakMap_methods); + INIT_CLASS_NAME(namespaced_name, "WeakMap"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_WeakMap_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 3, class_entry_ArrayAccess, class_entry_Countable, class_entry_IteratorAggregate); diff --git a/build/gen_stub.php b/build/gen_stub.php index f8e16064ee292..6ad6df59f6e32 100755 --- a/build/gen_stub.php +++ b/build/gen_stub.php @@ -3380,14 +3380,17 @@ public function getRegistration(array $allConstInfos): string $code .= "\tclass_entry->ce_flags |= $flags\n"; } } else { - $code .= "\tzend_class_entry ce, *class_entry;\n\n"; + $code .= "\tzend_class_entry ce, *class_entry;\n"; + $code .= "\tzend_namespaced_name namespaced_name;\n\n"; if (count($this->name->getParts()) > 1) { $className = $this->name->getLast(); $namespace = addslashes((string) $this->name->slice(0, -1)); - $code .= "\tINIT_NS_CLASS_ENTRY(ce, \"$namespace\", \"$className\", $classMethods);\n"; + $code .= "\tINIT_CLASS_NAME_NS(namespaced_name, \"$namespace\", \"$className\");\n"; + $code .= "\tINIT_CLASS_ENTRY(ce, namespaced_name, $classMethods);\n"; } else { - $code .= "\tINIT_CLASS_ENTRY(ce, \"$this->name\", $classMethods);\n"; + $code .= "\tINIT_CLASS_NAME(namespaced_name, \"$this->name\");\n"; + $code .= "\tINIT_CLASS_ENTRY(ce, namespaced_name, $classMethods);\n"; } if ($this->type === "class" || $this->type === "trait") { diff --git a/ext/bcmath/bcmath_arginfo.h b/ext/bcmath/bcmath_arginfo.h index 9edfd5cd65760..6213ec6afc662 100644 --- a/ext/bcmath/bcmath_arginfo.h +++ b/ext/bcmath/bcmath_arginfo.h @@ -197,8 +197,10 @@ static const zend_function_entry class_BcMath_Number_methods[] = { static zend_class_entry *register_class_BcMath_Number(zend_class_entry *class_entry_Stringable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "BcMath", "Number", class_BcMath_Number_methods); + INIT_CLASS_NAME_NS(namespaced_name, "BcMath", "Number"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_BcMath_Number_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_READONLY_CLASS); zend_class_implements(class_entry, 1, class_entry_Stringable); diff --git a/ext/com_dotnet/com_extension_arginfo.h b/ext/com_dotnet/com_extension_arginfo.h index b5773f17fda3d..4d22730b90b15 100644 --- a/ext/com_dotnet/com_extension_arginfo.h +++ b/ext/com_dotnet/com_extension_arginfo.h @@ -290,8 +290,10 @@ static void register_com_extension_symbols(int module_number) static zend_class_entry *register_class_variant(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "variant", class_variant_methods); + INIT_CLASS_NAME(namespaced_name, "variant"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_variant_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -300,8 +302,10 @@ static zend_class_entry *register_class_variant(void) static zend_class_entry *register_class_com(zend_class_entry *class_entry_variant) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "com", class_com_methods); + INIT_CLASS_NAME(namespaced_name, "com"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_com_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_variant, 0); return class_entry; @@ -311,8 +315,10 @@ static zend_class_entry *register_class_com(zend_class_entry *class_entry_varian static zend_class_entry *register_class_dotnet(zend_class_entry *class_entry_variant) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "dotnet", class_dotnet_methods); + INIT_CLASS_NAME(namespaced_name, "dotnet"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_dotnet_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_variant, 0); return class_entry; @@ -322,8 +328,10 @@ static zend_class_entry *register_class_dotnet(zend_class_entry *class_entry_var static zend_class_entry *register_class_com_safearray_proxy(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "com_safearray_proxy", NULL); + INIT_CLASS_NAME(namespaced_name, "com_safearray_proxy"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); return class_entry; @@ -332,8 +340,10 @@ static zend_class_entry *register_class_com_safearray_proxy(void) static zend_class_entry *register_class_com_exception(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "com_exception", NULL); + INIT_CLASS_NAME(namespaced_name, "com_exception"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, ZEND_ACC_FINAL); return class_entry; diff --git a/ext/com_dotnet/com_persist_arginfo.h b/ext/com_dotnet/com_persist_arginfo.h index 4449396e9ccef..47e5aa3e70f47 100644 --- a/ext/com_dotnet/com_persist_arginfo.h +++ b/ext/com_dotnet/com_persist_arginfo.h @@ -54,8 +54,10 @@ static const zend_function_entry class_COMPersistHelper_methods[] = { static zend_class_entry *register_class_COMPersistHelper(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "COMPersistHelper", class_COMPersistHelper_methods); + INIT_CLASS_NAME(namespaced_name, "COMPersistHelper"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_COMPersistHelper_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); return class_entry; diff --git a/ext/curl/curl_arginfo.h b/ext/curl/curl_arginfo.h index 6a81d1e92c88f..e00da99bc5517 100644 --- a/ext/curl/curl_arginfo.h +++ b/ext/curl/curl_arginfo.h @@ -1126,8 +1126,10 @@ static void register_curl_symbols(int module_number) static zend_class_entry *register_class_CurlHandle(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "CurlHandle", NULL); + INIT_CLASS_NAME(namespaced_name, "CurlHandle"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -1136,8 +1138,10 @@ static zend_class_entry *register_class_CurlHandle(void) static zend_class_entry *register_class_CurlMultiHandle(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "CurlMultiHandle", NULL); + INIT_CLASS_NAME(namespaced_name, "CurlMultiHandle"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -1146,8 +1150,10 @@ static zend_class_entry *register_class_CurlMultiHandle(void) static zend_class_entry *register_class_CurlShareHandle(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "CurlShareHandle", NULL); + INIT_CLASS_NAME(namespaced_name, "CurlShareHandle"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -1156,8 +1162,10 @@ static zend_class_entry *register_class_CurlShareHandle(void) static zend_class_entry *register_class_CurlSharePersistentHandle(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "CurlSharePersistentHandle", NULL); + INIT_CLASS_NAME(namespaced_name, "CurlSharePersistentHandle"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zval property_options_default_value; diff --git a/ext/curl/curl_file_arginfo.h b/ext/curl/curl_file_arginfo.h index e409c6e772513..aaa6df19f437a 100644 --- a/ext/curl/curl_file_arginfo.h +++ b/ext/curl/curl_file_arginfo.h @@ -54,8 +54,10 @@ static const zend_function_entry class_CURLStringFile_methods[] = { static zend_class_entry *register_class_CURLFile(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "CURLFile", class_CURLFile_methods); + INIT_CLASS_NAME(namespaced_name, "CURLFile"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_CURLFile_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval property_name_default_value; @@ -80,8 +82,10 @@ static zend_class_entry *register_class_CURLFile(void) static zend_class_entry *register_class_CURLStringFile(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "CURLStringFile", class_CURLStringFile_methods); + INIT_CLASS_NAME(namespaced_name, "CURLStringFile"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_CURLStringFile_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_data_default_value; diff --git a/ext/date/php_date.c b/ext/date/php_date.c index ed89c9d494a6f..fa549e2700db9 100644 --- a/ext/date/php_date.c +++ b/ext/date/php_date.c @@ -310,17 +310,17 @@ static zend_object_handlers date_object_handlers_period; static void date_throw_uninitialized_error(zend_class_entry *ce) { if (ce->type == ZEND_INTERNAL_CLASS) { - zend_throw_error(date_ce_date_object_error, "Object of type %s has not been correctly initialized by calling parent::__construct() in its constructor", ZSTR_VAL(ce->name)); + zend_throw_error(date_ce_date_object_error, "Object of type %s has not been correctly initialized by calling parent::__construct() in its constructor", ZSTR_VAL(ce->namespaced_name.name)); } else { zend_class_entry *ce_ptr = ce; while (ce_ptr && ce_ptr->parent && ce_ptr->type == ZEND_USER_CLASS) { ce_ptr = ce_ptr->parent; } if (ce_ptr->type != ZEND_INTERNAL_CLASS) { - zend_throw_error(date_ce_date_object_error, "Object of type %s not been correctly initialized by calling parent::__construct() in its constructor", ZSTR_VAL(ce->name)); + zend_throw_error(date_ce_date_object_error, "Object of type %s not been correctly initialized by calling parent::__construct() in its constructor", ZSTR_VAL(ce->namespaced_name.name)); return; } - zend_throw_error(date_ce_date_object_error, "Object of type %s (inheriting %s) has not been correctly initialized by calling parent::__construct() in its constructor", ZSTR_VAL(ce->name), ZSTR_VAL(ce_ptr->name)); + zend_throw_error(date_ce_date_object_error, "Object of type %s (inheriting %s) has not been correctly initialized by calling parent::__construct() in its constructor", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(ce_ptr->namespaced_name.name)); } } @@ -6070,7 +6070,7 @@ static HashTable *date_period_get_properties_for(zend_object *object, zend_prop_ static void date_period_unset_property(zend_object *object, zend_string *name, void **cache_slot) { if (date_period_is_internal_property(name)) { - zend_throw_error(NULL, "Cannot unset %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(name)); + zend_throw_error(NULL, "Cannot unset %s::$%s", ZSTR_VAL(object->ce->namespaced_name.name), ZSTR_VAL(name)); return; } diff --git a/ext/date/php_date_arginfo.h b/ext/date/php_date_arginfo.h index 8ce0114206cfe..30e2ed380fdf3 100644 --- a/ext/date/php_date_arginfo.h +++ b/ext/date/php_date_arginfo.h @@ -865,8 +865,10 @@ static void register_php_date_symbols(int module_number) static zend_class_entry *register_class_DateTimeInterface(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateTimeInterface", class_DateTimeInterface_methods); + INIT_CLASS_NAME(namespaced_name, "DateTimeInterface"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DateTimeInterface_methods); class_entry = zend_register_internal_interface(&ce); zval const_ATOM_value; @@ -973,8 +975,10 @@ static zend_class_entry *register_class_DateTimeInterface(void) static zend_class_entry *register_class_DateTime(zend_class_entry *class_entry_DateTimeInterface) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateTime", class_DateTime_methods); + INIT_CLASS_NAME(namespaced_name, "DateTime"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DateTime_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_DateTimeInterface); @@ -984,8 +988,10 @@ static zend_class_entry *register_class_DateTime(zend_class_entry *class_entry_D static zend_class_entry *register_class_DateTimeImmutable(zend_class_entry *class_entry_DateTimeInterface) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateTimeImmutable", class_DateTimeImmutable_methods); + INIT_CLASS_NAME(namespaced_name, "DateTimeImmutable"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DateTimeImmutable_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_DateTimeInterface); @@ -995,8 +1001,10 @@ static zend_class_entry *register_class_DateTimeImmutable(zend_class_entry *clas static zend_class_entry *register_class_DateTimeZone(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateTimeZone", class_DateTimeZone_methods); + INIT_CLASS_NAME(namespaced_name, "DateTimeZone"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DateTimeZone_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval const_AFRICA_value; @@ -1089,8 +1097,10 @@ static zend_class_entry *register_class_DateTimeZone(void) static zend_class_entry *register_class_DateInterval(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateInterval", class_DateInterval_methods); + INIT_CLASS_NAME(namespaced_name, "DateInterval"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DateInterval_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); return class_entry; @@ -1099,8 +1109,10 @@ static zend_class_entry *register_class_DateInterval(void) static zend_class_entry *register_class_DatePeriod(zend_class_entry *class_entry_IteratorAggregate) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DatePeriod", class_DatePeriod_methods); + INIT_CLASS_NAME(namespaced_name, "DatePeriod"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DatePeriod_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_IteratorAggregate); @@ -1168,8 +1180,10 @@ static zend_class_entry *register_class_DatePeriod(zend_class_entry *class_entry static zend_class_entry *register_class_DateError(zend_class_entry *class_entry_Error) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateError", NULL); + INIT_CLASS_NAME(namespaced_name, "DateError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Error, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; @@ -1178,8 +1192,10 @@ static zend_class_entry *register_class_DateError(zend_class_entry *class_entry_ static zend_class_entry *register_class_DateObjectError(zend_class_entry *class_entry_DateError) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateObjectError", NULL); + INIT_CLASS_NAME(namespaced_name, "DateObjectError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DateError, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; @@ -1188,8 +1204,10 @@ static zend_class_entry *register_class_DateObjectError(zend_class_entry *class_ static zend_class_entry *register_class_DateRangeError(zend_class_entry *class_entry_DateError) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateRangeError", NULL); + INIT_CLASS_NAME(namespaced_name, "DateRangeError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DateError, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; @@ -1198,8 +1216,10 @@ static zend_class_entry *register_class_DateRangeError(zend_class_entry *class_e static zend_class_entry *register_class_DateException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateException", NULL); + INIT_CLASS_NAME(namespaced_name, "DateException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; @@ -1208,8 +1228,10 @@ static zend_class_entry *register_class_DateException(zend_class_entry *class_en static zend_class_entry *register_class_DateInvalidTimeZoneException(zend_class_entry *class_entry_DateException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateInvalidTimeZoneException", NULL); + INIT_CLASS_NAME(namespaced_name, "DateInvalidTimeZoneException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DateException, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; @@ -1218,8 +1240,10 @@ static zend_class_entry *register_class_DateInvalidTimeZoneException(zend_class_ static zend_class_entry *register_class_DateInvalidOperationException(zend_class_entry *class_entry_DateException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateInvalidOperationException", NULL); + INIT_CLASS_NAME(namespaced_name, "DateInvalidOperationException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DateException, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; @@ -1228,8 +1252,10 @@ static zend_class_entry *register_class_DateInvalidOperationException(zend_class static zend_class_entry *register_class_DateMalformedStringException(zend_class_entry *class_entry_DateException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateMalformedStringException", NULL); + INIT_CLASS_NAME(namespaced_name, "DateMalformedStringException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DateException, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; @@ -1238,8 +1264,10 @@ static zend_class_entry *register_class_DateMalformedStringException(zend_class_ static zend_class_entry *register_class_DateMalformedIntervalStringException(zend_class_entry *class_entry_DateException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateMalformedIntervalStringException", NULL); + INIT_CLASS_NAME(namespaced_name, "DateMalformedIntervalStringException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DateException, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; @@ -1248,8 +1276,10 @@ static zend_class_entry *register_class_DateMalformedIntervalStringException(zen static zend_class_entry *register_class_DateMalformedPeriodStringException(zend_class_entry *class_entry_DateException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DateMalformedPeriodStringException", NULL); + INIT_CLASS_NAME(namespaced_name, "DateMalformedPeriodStringException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DateException, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; diff --git a/ext/dba/dba_arginfo.h b/ext/dba/dba_arginfo.h index 97a45381c92bf..efad86ebfd49e 100644 --- a/ext/dba/dba_arginfo.h +++ b/ext/dba/dba_arginfo.h @@ -108,8 +108,10 @@ static void register_dba_symbols(int module_number) static zend_class_entry *register_class_Dba_Connection(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dba", "Connection", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Dba", "Connection"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/dl_test/dl_test_arginfo.h b/ext/dl_test/dl_test_arginfo.h index 1b3b65aa7e677..344c6c805cdf6 100644 --- a/ext/dl_test/dl_test_arginfo.h +++ b/ext/dl_test/dl_test_arginfo.h @@ -41,8 +41,10 @@ static void register_dl_test_symbols(int module_number) static zend_class_entry *register_class_DlTest(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DlTest", class_DlTest_methods); + INIT_CLASS_NAME(namespaced_name, "DlTest"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DlTest_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); return class_entry; @@ -51,8 +53,10 @@ static zend_class_entry *register_class_DlTest(void) static zend_class_entry *register_class_DlTestSuperClass(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DlTestSuperClass", class_DlTestSuperClass_methods); + INIT_CLASS_NAME(namespaced_name, "DlTestSuperClass"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DlTestSuperClass_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_a_default_value; @@ -67,8 +71,10 @@ static zend_class_entry *register_class_DlTestSuperClass(void) static zend_class_entry *register_class_DlTestSubClass(zend_class_entry *class_entry_DlTestSuperClass) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DlTestSubClass", NULL); + INIT_CLASS_NAME(namespaced_name, "DlTestSubClass"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DlTestSuperClass, 0); return class_entry; @@ -77,8 +83,10 @@ static zend_class_entry *register_class_DlTestSubClass(zend_class_entry *class_e static zend_class_entry *register_class_DlTestAliasedClass(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DlTestAliasedClass", NULL); + INIT_CLASS_NAME(namespaced_name, "DlTestAliasedClass"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); return class_entry; diff --git a/ext/dom/document.c b/ext/dom/document.c index c7a8582e0872c..7267ead2d7060 100644 --- a/ext/dom/document.c +++ b/ext/dom/document.c @@ -2249,7 +2249,7 @@ static void dom_document_register_node_class(INTERNAL_FUNCTION_PARAMETERS, bool return; } - zend_argument_error(NULL, 2, "must be a class name derived from %s or null, %s given", ZSTR_VAL(basece->name), ZSTR_VAL(ce->name)); + zend_argument_error(NULL, 2, "must be a class name derived from %s or null, %s given", ZSTR_VAL(basece->namespaced_name.name), ZSTR_VAL(ce->namespaced_name.name)); RETURN_THROWS(); } diff --git a/ext/dom/html_collection.c b/ext/dom/html_collection.c index e4c0446016685..21a30db4aab31 100644 --- a/ext/dom/html_collection.c +++ b/ext/dom/html_collection.c @@ -101,13 +101,13 @@ PHP_METHOD(Dom_HTMLCollection, namedItem) zval *dom_html_collection_read_dimension(zend_object *object, zval *offset, int type, zval *rv) { if (UNEXPECTED(!offset)) { - zend_throw_error(NULL, "Cannot append to %s", ZSTR_VAL(object->ce->name)); + zend_throw_error(NULL, "Cannot append to %s", ZSTR_VAL(object->ce->namespaced_name.name)); return NULL; } dom_nodelist_dimension_index index = dom_modern_nodelist_get_index(offset); if (UNEXPECTED(index.type == DOM_NODELIST_DIM_ILLEGAL)) { - zend_illegal_container_offset(object->ce->name, offset, type); + zend_illegal_container_offset(object->ce->namespaced_name.name, offset, type); return NULL; } @@ -128,7 +128,7 @@ int dom_html_collection_has_dimension(zend_object *object, zval *member, int che dom_nodelist_dimension_index index = dom_modern_nodelist_get_index(member); if (UNEXPECTED(index.type == DOM_NODELIST_DIM_ILLEGAL)) { - zend_illegal_container_offset(object->ce->name, member, BP_VAR_IS); + zend_illegal_container_offset(object->ce->namespaced_name.name, member, BP_VAR_IS); return 0; } diff --git a/ext/dom/node.c b/ext/dom/node.c index c9bf45e887db8..f130b56107df5 100644 --- a/ext/dom/node.c +++ b/ext/dom/node.c @@ -2607,14 +2607,14 @@ PHP_METHOD(Dom_Node, compareDocumentPosition) PHP_METHOD(Dom_Node, __construct) { - zend_throw_error(NULL, "Cannot directly construct %s, use document methods instead", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name)); + zend_throw_error(NULL, "Cannot directly construct %s, use document methods instead", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->namespaced_name.name)); } PHP_METHOD(DOMNode, __sleep) { ZEND_PARSE_PARAMETERS_NONE(); - zend_throw_exception_ex(NULL, 0, "Serialization of '%s' is not allowed, unless serialization methods are implemented in a subclass", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name)); + zend_throw_exception_ex(NULL, 0, "Serialization of '%s' is not allowed, unless serialization methods are implemented in a subclass", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->namespaced_name.name)); RETURN_THROWS(); } @@ -2622,7 +2622,7 @@ PHP_METHOD(DOMNode, __wakeup) { ZEND_PARSE_PARAMETERS_NONE(); - zend_throw_exception_ex(NULL, 0, "Unserialization of '%s' is not allowed, unless unserialization methods are implemented in a subclass", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name)); + zend_throw_exception_ex(NULL, 0, "Unserialization of '%s' is not allowed, unless unserialization methods are implemented in a subclass", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->namespaced_name.name)); RETURN_THROWS(); } diff --git a/ext/dom/nodelist.c b/ext/dom/nodelist.c index 819b7396b69c7..087c6fe44430b 100644 --- a/ext/dom/nodelist.c +++ b/ext/dom/nodelist.c @@ -281,13 +281,13 @@ dom_nodelist_dimension_index dom_modern_nodelist_get_index(const zval *offset) zval *dom_modern_nodelist_read_dimension(zend_object *object, zval *offset, int type, zval *rv) { if (UNEXPECTED(!offset)) { - zend_throw_error(NULL, "Cannot append to %s", ZSTR_VAL(object->ce->name)); + zend_throw_error(NULL, "Cannot append to %s", ZSTR_VAL(object->ce->namespaced_name.name)); return NULL; } dom_nodelist_dimension_index index = dom_modern_nodelist_get_index(offset); if (UNEXPECTED(index.type == DOM_NODELIST_DIM_ILLEGAL || index.type == DOM_NODELIST_DIM_STRING)) { - zend_illegal_container_offset(object->ce->name, offset, type); + zend_illegal_container_offset(object->ce->namespaced_name.name, offset, type); return NULL; } @@ -302,7 +302,7 @@ int dom_modern_nodelist_has_dimension(zend_object *object, zval *member, int che dom_nodelist_dimension_index index = dom_modern_nodelist_get_index(member); if (UNEXPECTED(index.type == DOM_NODELIST_DIM_ILLEGAL || index.type == DOM_NODELIST_DIM_STRING)) { - zend_illegal_container_offset(object->ce->name, member, BP_VAR_IS); + zend_illegal_container_offset(object->ce->namespaced_name.name, member, BP_VAR_IS); return 0; } diff --git a/ext/dom/parentnode/tree.c b/ext/dom/parentnode/tree.c index f57fd1cc7335b..86ed3c9344a12 100644 --- a/ext/dom/parentnode/tree.c +++ b/ext/dom/parentnode/tree.c @@ -442,7 +442,7 @@ static zend_result dom_sanity_check_node_list_types(zval *nodes, uint32_t nodesc const zend_class_entry *ce = Z_OBJCE(nodes[i]); if (!instanceof_function(ce, node_ce)) { - zend_argument_type_error(i + 1, "must be of type %s|string, %s given", ZSTR_VAL(node_ce->name), zend_zval_type_name(&nodes[i])); + zend_argument_type_error(i + 1, "must be of type %s|string, %s given", ZSTR_VAL(node_ce->namespaced_name.name), zend_zval_type_name(&nodes[i])); return FAILURE; } } else if (type == IS_STRING) { @@ -451,7 +451,7 @@ static zend_result dom_sanity_check_node_list_types(zval *nodes, uint32_t nodesc return FAILURE; } } else { - zend_argument_type_error(i + 1, "must be of type %s|string, %s given", ZSTR_VAL(node_ce->name), zend_zval_type_name(&nodes[i])); + zend_argument_type_error(i + 1, "must be of type %s|string, %s given", ZSTR_VAL(node_ce->namespaced_name.name), zend_zval_type_name(&nodes[i])); return FAILURE; } } diff --git a/ext/dom/php_dom.c b/ext/dom/php_dom.c index 652ef22e506ab..08c9c9ef1d9f1 100644 --- a/ext/dom/php_dom.c +++ b/ext/dom/php_dom.c @@ -276,9 +276,9 @@ void dom_set_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece zend_hash_init(doc_props->classmap, 0, NULL, NULL, false); } if (ce) { - zend_hash_update_ptr(doc_props->classmap, basece->name, ce); + zend_hash_update_ptr(doc_props->classmap, basece->namespaced_name.name, ce); } else { - zend_hash_del(doc_props->classmap, basece->name); + zend_hash_del(doc_props->classmap, basece->namespaced_name.name); } } } @@ -288,7 +288,7 @@ zend_class_entry *dom_get_doc_classmap(php_libxml_ref_obj *document, zend_class_ if (document) { libxml_doc_props const* doc_props = dom_get_doc_props_read_only(document); if (doc_props->classmap) { - zend_class_entry *ce = zend_hash_find_ptr(doc_props->classmap, basece->name); + zend_class_entry *ce = zend_hash_find_ptr(doc_props->classmap, basece->namespaced_name.name); if (ce) { return ce; } @@ -411,7 +411,7 @@ zval *dom_write_property(zend_object *object, zend_string *name, zval *value, vo if (hnd) { if (UNEXPECTED(!hnd->write_func)) { - zend_readonly_property_modification_error_ex(ZSTR_VAL(object->ce->name), ZSTR_VAL(name)); + zend_readonly_property_modification_error_ex(ZSTR_VAL(object->ce->namespaced_name.name), ZSTR_VAL(name)); return &EG(error_zval); } @@ -477,7 +477,7 @@ static void dom_unset_property(zend_object *object, zend_string *member, void ** dom_object *obj = php_dom_obj_from_obj(object); if (obj->prop_handler != NULL && zend_hash_exists(obj->prop_handler, member)) { - zend_throw_error(NULL, "Cannot unset %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(member)); + zend_throw_error(NULL, "Cannot unset %s::$%s", ZSTR_VAL(object->ce->namespaced_name.name), ZSTR_VAL(member)); return; } @@ -849,7 +849,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_node_prop_handlers, "localName", dom_node_local_name_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_node_prop_handlers, "baseURI", dom_node_base_uri_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_node_prop_handlers, "textContent", dom_node_text_content_read, dom_node_text_content_write); - zend_hash_add_new_ptr(&classes, dom_node_class_entry->name, &dom_node_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_node_class_entry->namespaced_name.name, &dom_node_prop_handlers); dom_modern_node_class_entry = register_class_Dom_Node(); dom_modern_node_class_entry->create_object = dom_objects_new; @@ -871,7 +871,7 @@ PHP_MINIT_FUNCTION(dom) /* We will set-up the setter for the derived classes afterwards on a class-by-class basis. */ DOM_REGISTER_PROP_HANDLER(&dom_modern_node_prop_handlers, "nodeValue", dom_node_node_value_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_modern_node_prop_handlers, "textContent", dom_node_text_content_read, NULL); - zend_hash_add_new_ptr(&classes, dom_modern_node_class_entry->name, &dom_modern_node_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_node_class_entry->namespaced_name.name, &dom_modern_node_prop_handlers); dom_namespace_node_class_entry = register_class_DOMNameSpaceNode(); dom_namespace_node_class_entry->create_object = dom_objects_namespace_node_new; @@ -888,7 +888,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_namespace_node_prop_handlers, "ownerDocument", dom_node_owner_document_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_namespace_node_prop_handlers, "parentNode", dom_node_parent_node_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_namespace_node_prop_handlers, "parentElement", dom_node_parent_element_read, NULL); - zend_hash_add_new_ptr(&classes, dom_namespace_node_class_entry->name, &dom_namespace_node_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_namespace_node_class_entry->namespaced_name.name, &dom_namespace_node_prop_handlers); dom_namespace_info_class_entry = register_class_Dom_NamespaceInfo(); @@ -901,7 +901,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_documentfragment_prop_handlers, "lastElementChild", dom_parent_node_last_element_child_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_documentfragment_prop_handlers, "childElementCount", dom_parent_node_child_element_count, NULL); zend_hash_merge(&dom_documentfragment_prop_handlers, &dom_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_documentfragment_class_entry->name, &dom_documentfragment_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_documentfragment_class_entry->namespaced_name.name, &dom_documentfragment_prop_handlers); dom_modern_documentfragment_class_entry = register_class_Dom_DocumentFragment(dom_modern_node_class_entry, dom_modern_parentnode_class_entry); dom_modern_documentfragment_class_entry->create_object = dom_objects_new; @@ -913,7 +913,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_modern_documentfragment_prop_handlers, "childElementCount", dom_parent_node_child_element_count, NULL); zend_hash_merge(&dom_modern_documentfragment_prop_handlers, &dom_modern_node_prop_handlers, NULL, false); DOM_OVERWRITE_PROP_HANDLER(&dom_modern_documentfragment_prop_handlers, "textContent", dom_node_text_content_read, dom_node_text_content_write); - zend_hash_add_new_ptr(&classes, dom_modern_documentfragment_class_entry->name, &dom_modern_documentfragment_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_documentfragment_class_entry->namespaced_name.name, &dom_modern_documentfragment_prop_handlers); dom_abstract_base_document_class_entry = register_class_Dom_Document(dom_modern_node_class_entry, dom_modern_parentnode_class_entry); dom_abstract_base_document_class_entry->default_object_handlers = &dom_object_handlers; @@ -963,11 +963,11 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_document_prop_handlers, "childElementCount", dom_parent_node_child_element_count, NULL); zend_hash_merge(&dom_document_prop_handlers, &dom_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_document_class_entry->name, &dom_document_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_document_class_entry->namespaced_name.name, &dom_document_prop_handlers); dom_html_document_class_entry = register_class_Dom_HTMLDocument(dom_abstract_base_document_class_entry); dom_html_document_class_entry->default_object_handlers = &dom_object_handlers; - zend_hash_add_new_ptr(&classes, dom_html_document_class_entry->name, &dom_abstract_base_document_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_html_document_class_entry->namespaced_name.name, &dom_abstract_base_document_prop_handlers); dom_xml_document_class_entry = register_class_Dom_XMLDocument(dom_abstract_base_document_class_entry); dom_xml_document_class_entry->default_object_handlers = &dom_object_handlers; @@ -978,7 +978,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_xml_document_prop_handlers, "formatOutput", dom_document_format_output_read, dom_document_format_output_write); zend_hash_merge(&dom_xml_document_prop_handlers, &dom_abstract_base_document_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_xml_document_class_entry->name, &dom_xml_document_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_xml_document_class_entry->namespaced_name.name, &dom_xml_document_prop_handlers); dom_nodelist_class_entry = register_class_DOMNodeList(zend_ce_aggregate, zend_ce_countable); dom_nodelist_class_entry->create_object = dom_nnodemap_objects_new; @@ -987,14 +987,14 @@ PHP_MINIT_FUNCTION(dom) zend_hash_init(&dom_nodelist_prop_handlers, 0, NULL, NULL, true); DOM_REGISTER_PROP_HANDLER(&dom_nodelist_prop_handlers, "length", dom_nodelist_length_read, NULL); - zend_hash_add_new_ptr(&classes, dom_nodelist_class_entry->name, &dom_nodelist_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_nodelist_class_entry->namespaced_name.name, &dom_nodelist_prop_handlers); dom_modern_nodelist_class_entry = register_class_Dom_NodeList(zend_ce_aggregate, zend_ce_countable); dom_modern_nodelist_class_entry->create_object = dom_nnodemap_objects_new; dom_modern_nodelist_class_entry->default_object_handlers = &dom_modern_nodelist_object_handlers; dom_modern_nodelist_class_entry->get_iterator = php_dom_get_iterator; - zend_hash_add_new_ptr(&classes, dom_modern_nodelist_class_entry->name, &dom_nodelist_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_nodelist_class_entry->namespaced_name.name, &dom_nodelist_prop_handlers); dom_namednodemap_class_entry = register_class_DOMNamedNodeMap(zend_ce_aggregate, zend_ce_countable); dom_namednodemap_class_entry->create_object = dom_nnodemap_objects_new; @@ -1003,28 +1003,28 @@ PHP_MINIT_FUNCTION(dom) zend_hash_init(&dom_namednodemap_prop_handlers, 0, NULL, NULL, true); DOM_REGISTER_PROP_HANDLER(&dom_namednodemap_prop_handlers, "length", dom_namednodemap_length_read, NULL); - zend_hash_add_new_ptr(&classes, dom_namednodemap_class_entry->name, &dom_namednodemap_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_namednodemap_class_entry->namespaced_name.name, &dom_namednodemap_prop_handlers); dom_modern_namednodemap_class_entry = register_class_Dom_NamedNodeMap(zend_ce_aggregate, zend_ce_countable); dom_modern_namednodemap_class_entry->create_object = dom_nnodemap_objects_new; dom_modern_namednodemap_class_entry->default_object_handlers = &dom_modern_nnodemap_object_handlers; dom_modern_namednodemap_class_entry->get_iterator = php_dom_get_iterator; - zend_hash_add_new_ptr(&classes, dom_modern_namednodemap_class_entry->name, &dom_namednodemap_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_namednodemap_class_entry->namespaced_name.name, &dom_namednodemap_prop_handlers); dom_modern_dtd_namednodemap_class_entry = register_class_Dom_DtdNamedNodeMap(zend_ce_aggregate, zend_ce_countable); dom_modern_dtd_namednodemap_class_entry->create_object = dom_nnodemap_objects_new; dom_modern_dtd_namednodemap_class_entry->default_object_handlers = &dom_modern_nnodemap_object_handlers; dom_modern_dtd_namednodemap_class_entry->get_iterator = php_dom_get_iterator; - zend_hash_add_new_ptr(&classes, dom_modern_dtd_namednodemap_class_entry->name, &dom_namednodemap_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_dtd_namednodemap_class_entry->namespaced_name.name, &dom_namednodemap_prop_handlers); dom_html_collection_class_entry = register_class_Dom_HTMLCollection(zend_ce_aggregate, zend_ce_countable); dom_html_collection_class_entry->create_object = dom_nnodemap_objects_new; dom_html_collection_class_entry->default_object_handlers = &dom_html_collection_object_handlers; dom_html_collection_class_entry->get_iterator = php_dom_get_iterator; - zend_hash_add_new_ptr(&classes, dom_html_collection_class_entry->name, &dom_nodelist_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_html_collection_class_entry->namespaced_name.name, &dom_nodelist_prop_handlers); dom_characterdata_class_entry = register_class_DOMCharacterData(dom_node_class_entry, dom_childnode_class_entry); dom_characterdata_class_entry->create_object = dom_objects_new; @@ -1036,7 +1036,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_characterdata_prop_handlers, "previousElementSibling", dom_node_previous_element_sibling_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_characterdata_prop_handlers, "nextElementSibling", dom_node_next_element_sibling_read, NULL); zend_hash_merge(&dom_characterdata_prop_handlers, &dom_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_characterdata_class_entry->name, &dom_characterdata_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_characterdata_class_entry->namespaced_name.name, &dom_characterdata_prop_handlers); dom_modern_characterdata_class_entry = register_class_Dom_CharacterData(dom_modern_node_class_entry, dom_modern_childnode_class_entry); dom_modern_characterdata_class_entry->create_object = dom_objects_new; @@ -1050,7 +1050,7 @@ PHP_MINIT_FUNCTION(dom) zend_hash_merge(&dom_modern_characterdata_prop_handlers, &dom_modern_node_prop_handlers, NULL, false); DOM_OVERWRITE_PROP_HANDLER(&dom_modern_characterdata_prop_handlers, "nodeValue", dom_node_node_value_read, dom_node_node_value_write); DOM_OVERWRITE_PROP_HANDLER(&dom_modern_characterdata_prop_handlers, "textContent", dom_node_text_content_read, dom_node_text_content_write); - zend_hash_add_new_ptr(&classes, dom_modern_characterdata_class_entry->name, &dom_modern_characterdata_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_characterdata_class_entry->namespaced_name.name, &dom_modern_characterdata_prop_handlers); dom_attr_class_entry = register_class_DOMAttr(dom_node_class_entry); dom_attr_class_entry->create_object = dom_objects_new; @@ -1063,7 +1063,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_attr_prop_handlers, "ownerElement", dom_attr_owner_element_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_attr_prop_handlers, "schemaTypeInfo", dom_attr_schema_type_info_read, NULL); zend_hash_merge(&dom_attr_prop_handlers, &dom_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_attr_class_entry->name, &dom_attr_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_attr_class_entry->namespaced_name.name, &dom_attr_prop_handlers); dom_modern_attr_class_entry = register_class_Dom_Attr(dom_modern_node_class_entry); dom_modern_attr_class_entry->create_object = dom_objects_new; @@ -1080,7 +1080,7 @@ PHP_MINIT_FUNCTION(dom) zend_hash_merge(&dom_modern_attr_prop_handlers, &dom_modern_node_prop_handlers, NULL, false); DOM_OVERWRITE_PROP_HANDLER(&dom_modern_attr_prop_handlers, "nodeValue", dom_node_node_value_read, dom_node_node_value_write); DOM_OVERWRITE_PROP_HANDLER(&dom_modern_attr_prop_handlers, "textContent", dom_node_text_content_read, dom_node_text_content_write); - zend_hash_add_new_ptr(&classes, dom_modern_attr_class_entry->name, &dom_modern_attr_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_attr_class_entry->namespaced_name.name, &dom_modern_attr_prop_handlers); dom_element_class_entry = register_class_DOMElement(dom_node_class_entry, dom_parentnode_class_entry, dom_childnode_class_entry); dom_element_class_entry->create_object = dom_objects_new; @@ -1097,7 +1097,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_element_prop_handlers, "previousElementSibling", dom_node_previous_element_sibling_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_element_prop_handlers, "nextElementSibling", dom_node_next_element_sibling_read, NULL); zend_hash_merge(&dom_element_prop_handlers, &dom_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_element_class_entry->name, &dom_element_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_element_class_entry->namespaced_name.name, &dom_element_prop_handlers); dom_modern_element_class_entry = register_class_Dom_Element(dom_modern_node_class_entry, dom_modern_parentnode_class_entry, dom_modern_childnode_class_entry); dom_modern_element_class_entry->create_object = dom_objects_new; @@ -1122,12 +1122,12 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_modern_element_prop_handlers, "substitutedNodeValue", dom_modern_element_substituted_node_value_read, dom_modern_element_substituted_node_value_write); zend_hash_merge(&dom_modern_element_prop_handlers, &dom_modern_node_prop_handlers, NULL, false); DOM_OVERWRITE_PROP_HANDLER(&dom_modern_element_prop_handlers, "textContent", dom_node_text_content_read, dom_node_text_content_write); - zend_hash_add_new_ptr(&classes, dom_modern_element_class_entry->name, &dom_modern_element_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_element_class_entry->namespaced_name.name, &dom_modern_element_prop_handlers); dom_html_element_class_entry = register_class_Dom_HTMLElement(dom_modern_element_class_entry); dom_html_element_class_entry->create_object = dom_objects_new; dom_html_element_class_entry->default_object_handlers = &dom_object_handlers; - zend_hash_add_new_ptr(&classes, dom_html_element_class_entry->name, &dom_modern_element_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_html_element_class_entry->namespaced_name.name, &dom_modern_element_prop_handlers); dom_text_class_entry = register_class_DOMText(dom_characterdata_class_entry); dom_text_class_entry->create_object = dom_objects_new; @@ -1136,7 +1136,7 @@ PHP_MINIT_FUNCTION(dom) zend_hash_init(&dom_text_prop_handlers, 0, NULL, NULL, true); DOM_REGISTER_PROP_HANDLER(&dom_text_prop_handlers, "wholeText", dom_text_whole_text_read, NULL); zend_hash_merge(&dom_text_prop_handlers, &dom_characterdata_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_text_class_entry->name, &dom_text_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_text_class_entry->namespaced_name.name, &dom_text_prop_handlers); dom_modern_text_class_entry = register_class_Dom_Text(dom_modern_characterdata_class_entry); dom_modern_text_class_entry->create_object = dom_objects_new; @@ -1145,27 +1145,27 @@ PHP_MINIT_FUNCTION(dom) zend_hash_init(&dom_modern_text_prop_handlers, 0, NULL, NULL, true); DOM_REGISTER_PROP_HANDLER(&dom_modern_text_prop_handlers, "wholeText", dom_text_whole_text_read, NULL); zend_hash_merge(&dom_modern_text_prop_handlers, &dom_modern_characterdata_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_modern_text_class_entry->name, &dom_modern_text_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_text_class_entry->namespaced_name.name, &dom_modern_text_prop_handlers); dom_comment_class_entry = register_class_DOMComment(dom_characterdata_class_entry); dom_comment_class_entry->create_object = dom_objects_new; dom_comment_class_entry->default_object_handlers = &dom_object_handlers; - zend_hash_add_new_ptr(&classes, dom_comment_class_entry->name, &dom_characterdata_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_comment_class_entry->namespaced_name.name, &dom_characterdata_prop_handlers); dom_modern_comment_class_entry = register_class_Dom_Comment(dom_modern_characterdata_class_entry); dom_modern_comment_class_entry->create_object = dom_objects_new; dom_modern_comment_class_entry->default_object_handlers = &dom_object_handlers; - zend_hash_add_new_ptr(&classes, dom_modern_comment_class_entry->name, &dom_modern_characterdata_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_comment_class_entry->namespaced_name.name, &dom_modern_characterdata_prop_handlers); dom_cdatasection_class_entry = register_class_DOMCdataSection(dom_text_class_entry); dom_cdatasection_class_entry->create_object = dom_objects_new; dom_cdatasection_class_entry->default_object_handlers = &dom_object_handlers; - zend_hash_add_new_ptr(&classes, dom_cdatasection_class_entry->name, &dom_text_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_cdatasection_class_entry->namespaced_name.name, &dom_text_prop_handlers); dom_modern_cdatasection_class_entry = register_class_Dom_CDATASection(dom_modern_text_class_entry); dom_modern_cdatasection_class_entry->create_object = dom_objects_new; dom_modern_cdatasection_class_entry->default_object_handlers = &dom_object_handlers; - zend_hash_add_new_ptr(&classes, dom_modern_cdatasection_class_entry->name, &dom_modern_text_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_cdatasection_class_entry->namespaced_name.name, &dom_modern_text_prop_handlers); dom_documenttype_class_entry = register_class_DOMDocumentType(dom_node_class_entry); dom_documenttype_class_entry->create_object = dom_objects_new; @@ -1179,7 +1179,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_documenttype_prop_handlers, "systemId", dom_documenttype_system_id_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_documenttype_prop_handlers, "internalSubset", dom_documenttype_internal_subset_read, NULL); zend_hash_merge(&dom_documenttype_prop_handlers, &dom_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_documenttype_class_entry->name, &dom_documenttype_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_documenttype_class_entry->namespaced_name.name, &dom_documenttype_prop_handlers); dom_modern_documenttype_class_entry = register_class_Dom_DocumentType(dom_modern_node_class_entry, dom_modern_childnode_class_entry); dom_modern_documenttype_class_entry->create_object = dom_objects_new; @@ -1193,7 +1193,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_modern_documenttype_prop_handlers, "systemId", dom_documenttype_system_id_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_modern_documenttype_prop_handlers, "internalSubset", dom_documenttype_internal_subset_read, NULL); zend_hash_merge(&dom_modern_documenttype_prop_handlers, &dom_modern_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_modern_documenttype_class_entry->name, &dom_modern_documenttype_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_documenttype_class_entry->namespaced_name.name, &dom_modern_documenttype_prop_handlers); dom_notation_class_entry = register_class_DOMNotation(dom_node_class_entry); dom_notation_class_entry->create_object = dom_objects_new; @@ -1203,7 +1203,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_notation_prop_handlers, "publicId", dom_notation_public_id_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_notation_prop_handlers, "systemId", dom_notation_system_id_read, NULL); zend_hash_merge(&dom_notation_prop_handlers, &dom_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_notation_class_entry->name, &dom_notation_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_notation_class_entry->namespaced_name.name, &dom_notation_prop_handlers); dom_modern_notation_class_entry = register_class_Dom_Notation(dom_modern_node_class_entry); dom_modern_notation_class_entry->create_object = dom_objects_new; @@ -1213,7 +1213,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_modern_notation_prop_handlers, "publicId", dom_notation_public_id_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_modern_notation_prop_handlers, "systemId", dom_notation_system_id_read, NULL); zend_hash_merge(&dom_modern_notation_prop_handlers, &dom_modern_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_modern_notation_class_entry->name, &dom_modern_node_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_notation_class_entry->namespaced_name.name, &dom_modern_node_prop_handlers); dom_entity_class_entry = register_class_DOMEntity(dom_node_class_entry); dom_entity_class_entry->create_object = dom_objects_new; @@ -1227,7 +1227,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_entity_prop_handlers, "encoding", dom_entity_encoding_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_entity_prop_handlers, "version", dom_entity_version_read, NULL); zend_hash_merge(&dom_entity_prop_handlers, &dom_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_entity_class_entry->name, &dom_entity_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_entity_class_entry->namespaced_name.name, &dom_entity_prop_handlers); dom_modern_entity_class_entry = register_class_Dom_Entity(dom_modern_node_class_entry); dom_modern_entity_class_entry->create_object = dom_objects_new; @@ -1238,7 +1238,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_modern_entity_prop_handlers, "systemId", dom_entity_system_id_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_modern_entity_prop_handlers, "notationName", dom_entity_notation_name_read, NULL); zend_hash_merge(&dom_modern_entity_prop_handlers, &dom_modern_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_modern_entity_class_entry->name, &dom_modern_entity_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_entity_class_entry->namespaced_name.name, &dom_modern_entity_prop_handlers); dom_entityreference_class_entry = register_class_DOMEntityReference(dom_node_class_entry); dom_entityreference_class_entry->create_object = dom_objects_new; @@ -1250,7 +1250,7 @@ PHP_MINIT_FUNCTION(dom) DOM_OVERWRITE_PROP_HANDLER(&dom_entity_reference_prop_handlers, "lastChild", dom_entity_reference_child_read, NULL); DOM_OVERWRITE_PROP_HANDLER(&dom_entity_reference_prop_handlers, "textContent", dom_entity_reference_text_content_read, NULL); DOM_OVERWRITE_PROP_HANDLER(&dom_entity_reference_prop_handlers, "childNodes", dom_entity_reference_child_nodes_read, NULL); - zend_hash_add_new_ptr(&classes, dom_entityreference_class_entry->name, &dom_entity_reference_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_entityreference_class_entry->namespaced_name.name, &dom_entity_reference_prop_handlers); dom_modern_entityreference_class_entry = register_class_Dom_EntityReference(dom_modern_node_class_entry); dom_modern_entityreference_class_entry->create_object = dom_objects_new; @@ -1262,7 +1262,7 @@ PHP_MINIT_FUNCTION(dom) DOM_OVERWRITE_PROP_HANDLER(&dom_modern_entity_reference_prop_handlers, "lastChild", dom_entity_reference_child_read, NULL); DOM_OVERWRITE_PROP_HANDLER(&dom_modern_entity_reference_prop_handlers, "textContent", dom_entity_reference_text_content_read, NULL); DOM_OVERWRITE_PROP_HANDLER(&dom_modern_entity_reference_prop_handlers, "childNodes", dom_entity_reference_child_nodes_read, NULL); - zend_hash_add_new_ptr(&classes, dom_modern_entityreference_class_entry->name, &dom_modern_entity_reference_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_entityreference_class_entry->namespaced_name.name, &dom_modern_entity_reference_prop_handlers); dom_processinginstruction_class_entry = register_class_DOMProcessingInstruction(dom_node_class_entry); dom_processinginstruction_class_entry->create_object = dom_objects_new; @@ -1272,7 +1272,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_processinginstruction_prop_handlers, "target", dom_processinginstruction_target_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_processinginstruction_prop_handlers, "data", dom_processinginstruction_data_read, dom_processinginstruction_data_write); zend_hash_merge(&dom_processinginstruction_prop_handlers, &dom_node_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_processinginstruction_class_entry->name, &dom_processinginstruction_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_processinginstruction_class_entry->namespaced_name.name, &dom_processinginstruction_prop_handlers); dom_modern_processinginstruction_class_entry = register_class_Dom_ProcessingInstruction(dom_modern_characterdata_class_entry); dom_modern_processinginstruction_class_entry->create_object = dom_objects_new; @@ -1282,7 +1282,7 @@ PHP_MINIT_FUNCTION(dom) DOM_REGISTER_PROP_HANDLER(&dom_modern_processinginstruction_prop_handlers, "target", dom_processinginstruction_target_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_modern_processinginstruction_prop_handlers, "data", dom_processinginstruction_data_read, dom_processinginstruction_data_write); zend_hash_merge(&dom_modern_processinginstruction_prop_handlers, &dom_modern_characterdata_prop_handlers, NULL, false); - zend_hash_add_new_ptr(&classes, dom_modern_processinginstruction_class_entry->name, &dom_modern_processinginstruction_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_processinginstruction_class_entry->namespaced_name.name, &dom_modern_processinginstruction_prop_handlers); #ifdef LIBXML_XPATH_ENABLED memcpy(&dom_xpath_object_handlers, &dom_object_handlers, sizeof(zend_object_handlers)); @@ -1298,13 +1298,13 @@ PHP_MINIT_FUNCTION(dom) zend_hash_init(&dom_xpath_prop_handlers, 0, NULL, NULL, true); DOM_REGISTER_PROP_HANDLER(&dom_xpath_prop_handlers, "document", dom_xpath_document_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_xpath_prop_handlers, "registerNodeNamespaces", dom_xpath_register_node_ns_read, dom_xpath_register_node_ns_write); - zend_hash_add_new_ptr(&classes, dom_xpath_class_entry->name, &dom_xpath_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_xpath_class_entry->namespaced_name.name, &dom_xpath_prop_handlers); dom_modern_xpath_class_entry = register_class_Dom_XPath(); dom_modern_xpath_class_entry->create_object = dom_xpath_objects_new; dom_modern_xpath_class_entry->default_object_handlers = &dom_xpath_object_handlers; - zend_hash_add_new_ptr(&classes, dom_modern_xpath_class_entry->name, &dom_xpath_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_modern_xpath_class_entry->namespaced_name.name, &dom_xpath_prop_handlers); #endif dom_token_list_class_entry = register_class_Dom_TokenList(zend_ce_aggregate, zend_ce_countable); @@ -1315,7 +1315,7 @@ PHP_MINIT_FUNCTION(dom) zend_hash_init(&dom_token_list_prop_handlers, 0, NULL, NULL, true); DOM_REGISTER_PROP_HANDLER(&dom_token_list_prop_handlers, "length", dom_token_list_length_read, NULL); DOM_REGISTER_PROP_HANDLER(&dom_token_list_prop_handlers, "value", dom_token_list_value_read, dom_token_list_value_write); - zend_hash_add_new_ptr(&classes, dom_token_list_class_entry->name, &dom_token_list_prop_handlers); + zend_hash_add_new_ptr(&classes, dom_token_list_class_entry->namespaced_name.name, &dom_token_list_prop_handlers); register_php_dom_symbols(module_number); @@ -1504,7 +1504,7 @@ static void dom_objects_set_class_ex(zend_class_entry *class_type, dom_object *i base_class = base_class->parent; } - intern->prop_handler = zend_hash_find_ptr(&classes, base_class->name); + intern->prop_handler = zend_hash_find_ptr(&classes, base_class->namespaced_name.name); zend_object_std_init(&intern->std, class_type); object_properties_init(&intern->std, class_type); @@ -2293,7 +2293,7 @@ static bool dom_nodemap_or_nodelist_process_offset_as_named(zval *offset, zend_l static zval *dom_nodelist_read_dimension(zend_object *object, zval *offset, int type, zval *rv) { if (UNEXPECTED(!offset)) { - zend_throw_error(NULL, "Cannot access %s without offset", ZSTR_VAL(object->ce->name)); + zend_throw_error(NULL, "Cannot access %s without offset", ZSTR_VAL(object->ce->namespaced_name.name)); return NULL; } @@ -2385,7 +2385,7 @@ void php_dom_get_content_into_zval(const xmlNode *nodep, zval *return_value, boo static zval *dom_nodemap_read_dimension(zend_object *object, zval *offset, int type, zval *rv) { if (UNEXPECTED(!offset)) { - zend_throw_error(NULL, "Cannot access %s without offset", ZSTR_VAL(object->ce->name)); + zend_throw_error(NULL, "Cannot access %s without offset", ZSTR_VAL(object->ce->namespaced_name.name)); return NULL; } @@ -2427,7 +2427,7 @@ static int dom_nodemap_has_dimension(zend_object *object, zval *member, int chec static zval *dom_modern_nodemap_read_dimension(zend_object *object, zval *offset, int type, zval *rv) { if (UNEXPECTED(!offset)) { - zend_throw_error(NULL, "Cannot append to %s", ZSTR_VAL(object->ce->name)); + zend_throw_error(NULL, "Cannot append to %s", ZSTR_VAL(object->ce->namespaced_name.name)); return NULL; } @@ -2446,7 +2446,7 @@ static zval *dom_modern_nodemap_read_dimension(zend_object *object, zval *offset } else if (Z_TYPE_P(offset) == IS_DOUBLE) { php_dom_named_node_map_get_item_into_zval(map, zend_dval_to_lval_safe(Z_DVAL_P(offset)), rv); } else { - zend_illegal_container_offset(object->ce->name, offset, type); + zend_illegal_container_offset(object->ce->namespaced_name.name, offset, type); return NULL; } @@ -2476,7 +2476,7 @@ static int dom_modern_nodemap_has_dimension(zend_object *object, zval *member, i zend_long offset = zend_dval_to_lval_safe(Z_DVAL_P(member)); return offset >= 0 && offset < php_dom_get_namednodemap_length(obj); } else { - zend_illegal_container_offset(object->ce->name, member, BP_VAR_IS); + zend_illegal_container_offset(object->ce->namespaced_name.name, member, BP_VAR_IS); return 0; } } diff --git a/ext/dom/php_dom.h b/ext/dom/php_dom.h index 438857305db66..3ee8346132288 100644 --- a/ext/dom/php_dom.h +++ b/ext/dom/php_dom.h @@ -221,7 +221,7 @@ xmlNodePtr dom_nodelist_iter_start_first_child(xmlNodePtr nodep); #define DOM_GET_INTERN(__id, __intern) { \ __intern = Z_DOMOBJ_P(__id); \ if (UNEXPECTED(__intern->ptr == NULL)) { \ - zend_throw_error(NULL, "Couldn't fetch %s", ZSTR_VAL(__intern->std.ce->name));\ + zend_throw_error(NULL, "Couldn't fetch %s", ZSTR_VAL(__intern->std.ce->namespaced_name.name));\ RETURN_THROWS();\ } \ } diff --git a/ext/dom/php_dom_arginfo.h b/ext/dom/php_dom_arginfo.h index 5c21b909b0e18..92cc389fc82e9 100644 --- a/ext/dom/php_dom_arginfo.h +++ b/ext/dom/php_dom_arginfo.h @@ -1875,8 +1875,10 @@ static void register_php_dom_symbols(int module_number) static zend_class_entry *register_class_DOMDocumentType(zend_class_entry *class_entry_DOMNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMDocumentType", NULL); + INIT_CLASS_NAME(namespaced_name, "DOMDocumentType"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMNode, 0); zval property_name_default_value; @@ -1921,8 +1923,10 @@ static zend_class_entry *register_class_DOMDocumentType(zend_class_entry *class_ static zend_class_entry *register_class_DOMCdataSection(zend_class_entry *class_entry_DOMText) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMCdataSection", class_DOMCdataSection_methods); + INIT_CLASS_NAME(namespaced_name, "DOMCdataSection"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMCdataSection_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMText, 0); return class_entry; @@ -1931,8 +1935,10 @@ static zend_class_entry *register_class_DOMCdataSection(zend_class_entry *class_ static zend_class_entry *register_class_DOMComment(zend_class_entry *class_entry_DOMCharacterData) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMComment", class_DOMComment_methods); + INIT_CLASS_NAME(namespaced_name, "DOMComment"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMComment_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMCharacterData, 0); return class_entry; @@ -1941,8 +1947,10 @@ static zend_class_entry *register_class_DOMComment(zend_class_entry *class_entry static zend_class_entry *register_class_DOMParentNode(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMParentNode", class_DOMParentNode_methods); + INIT_CLASS_NAME(namespaced_name, "DOMParentNode"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMParentNode_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -1951,8 +1959,10 @@ static zend_class_entry *register_class_DOMParentNode(void) static zend_class_entry *register_class_DOMChildNode(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMChildNode", class_DOMChildNode_methods); + INIT_CLASS_NAME(namespaced_name, "DOMChildNode"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMChildNode_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -1961,8 +1971,10 @@ static zend_class_entry *register_class_DOMChildNode(void) static zend_class_entry *register_class_DOMNode(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMNode", class_DOMNode_methods); + INIT_CLASS_NAME(namespaced_name, "DOMNode"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMNode_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval const_DOCUMENT_POSITION_DISCONNECTED_value; @@ -2124,8 +2136,10 @@ static zend_class_entry *register_class_DOMNode(void) static zend_class_entry *register_class_DOMNameSpaceNode(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMNameSpaceNode", class_DOMNameSpaceNode_methods); + INIT_CLASS_NAME(namespaced_name, "DOMNameSpaceNode"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMNameSpaceNode_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_nodeName_default_value; @@ -2197,8 +2211,10 @@ static zend_class_entry *register_class_DOMNameSpaceNode(void) static zend_class_entry *register_class_DOMImplementation(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMImplementation", class_DOMImplementation_methods); + INIT_CLASS_NAME(namespaced_name, "DOMImplementation"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMImplementation_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); return class_entry; @@ -2207,8 +2223,10 @@ static zend_class_entry *register_class_DOMImplementation(void) static zend_class_entry *register_class_DOMDocumentFragment(zend_class_entry *class_entry_DOMNode, zend_class_entry *class_entry_DOMParentNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMDocumentFragment", class_DOMDocumentFragment_methods); + INIT_CLASS_NAME(namespaced_name, "DOMDocumentFragment"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMDocumentFragment_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMNode, 0); zend_class_implements(class_entry, 1, class_entry_DOMParentNode); @@ -2238,8 +2256,10 @@ static zend_class_entry *register_class_DOMDocumentFragment(zend_class_entry *cl static zend_class_entry *register_class_DOMNodeList(zend_class_entry *class_entry_IteratorAggregate, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMNodeList", class_DOMNodeList_methods); + INIT_CLASS_NAME(namespaced_name, "DOMNodeList"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMNodeList_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 2, class_entry_IteratorAggregate, class_entry_Countable); @@ -2255,8 +2275,10 @@ static zend_class_entry *register_class_DOMNodeList(zend_class_entry *class_entr static zend_class_entry *register_class_DOMCharacterData(zend_class_entry *class_entry_DOMNode, zend_class_entry *class_entry_DOMChildNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMCharacterData", class_DOMCharacterData_methods); + INIT_CLASS_NAME(namespaced_name, "DOMCharacterData"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMCharacterData_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMNode, 0); zend_class_implements(class_entry, 1, class_entry_DOMChildNode); @@ -2292,8 +2314,10 @@ static zend_class_entry *register_class_DOMCharacterData(zend_class_entry *class static zend_class_entry *register_class_DOMAttr(zend_class_entry *class_entry_DOMNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMAttr", class_DOMAttr_methods); + INIT_CLASS_NAME(namespaced_name, "DOMAttr"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMAttr_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMNode, 0); zval property_name_default_value; @@ -2329,8 +2353,10 @@ static zend_class_entry *register_class_DOMAttr(zend_class_entry *class_entry_DO static zend_class_entry *register_class_DOMElement(zend_class_entry *class_entry_DOMNode, zend_class_entry *class_entry_DOMParentNode, zend_class_entry *class_entry_DOMChildNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMElement", class_DOMElement_methods); + INIT_CLASS_NAME(namespaced_name, "DOMElement"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMElement_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMNode, 0); zend_class_implements(class_entry, 2, class_entry_DOMParentNode, class_entry_DOMChildNode); @@ -2398,8 +2424,10 @@ static zend_class_entry *register_class_DOMElement(zend_class_entry *class_entry static zend_class_entry *register_class_DOMDocument(zend_class_entry *class_entry_DOMNode, zend_class_entry *class_entry_DOMParentNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMDocument", class_DOMDocument_methods); + INIT_CLASS_NAME(namespaced_name, "DOMDocument"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMDocument_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMNode, 0); zend_class_implements(class_entry, 1, class_entry_DOMParentNode); @@ -2546,8 +2574,10 @@ static zend_class_entry *register_class_DOMDocument(zend_class_entry *class_entr static zend_class_entry *register_class_DOMException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMException", NULL); + INIT_CLASS_NAME(namespaced_name, "DOMException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, ZEND_ACC_FINAL); zend_register_class_alias("Dom\\DOMException", class_entry); @@ -2561,8 +2591,10 @@ static zend_class_entry *register_class_DOMException(zend_class_entry *class_ent static zend_class_entry *register_class_DOMText(zend_class_entry *class_entry_DOMCharacterData) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMText", class_DOMText_methods); + INIT_CLASS_NAME(namespaced_name, "DOMText"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMText_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMCharacterData, 0); zval property_wholeText_default_value; @@ -2577,8 +2609,10 @@ static zend_class_entry *register_class_DOMText(zend_class_entry *class_entry_DO static zend_class_entry *register_class_DOMNamedNodeMap(zend_class_entry *class_entry_IteratorAggregate, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMNamedNodeMap", class_DOMNamedNodeMap_methods); + INIT_CLASS_NAME(namespaced_name, "DOMNamedNodeMap"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMNamedNodeMap_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 2, class_entry_IteratorAggregate, class_entry_Countable); @@ -2594,8 +2628,10 @@ static zend_class_entry *register_class_DOMNamedNodeMap(zend_class_entry *class_ static zend_class_entry *register_class_DOMEntity(zend_class_entry *class_entry_DOMNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMEntity", NULL); + INIT_CLASS_NAME(namespaced_name, "DOMEntity"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMNode, 0); zval property_publicId_default_value; @@ -2640,8 +2676,10 @@ static zend_class_entry *register_class_DOMEntity(zend_class_entry *class_entry_ static zend_class_entry *register_class_DOMEntityReference(zend_class_entry *class_entry_DOMNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMEntityReference", class_DOMEntityReference_methods); + INIT_CLASS_NAME(namespaced_name, "DOMEntityReference"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMEntityReference_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMNode, 0); return class_entry; @@ -2650,8 +2688,10 @@ static zend_class_entry *register_class_DOMEntityReference(zend_class_entry *cla static zend_class_entry *register_class_DOMNotation(zend_class_entry *class_entry_DOMNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMNotation", NULL); + INIT_CLASS_NAME(namespaced_name, "DOMNotation"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMNode, 0); zval property_publicId_default_value; @@ -2672,8 +2712,10 @@ static zend_class_entry *register_class_DOMNotation(zend_class_entry *class_entr static zend_class_entry *register_class_DOMProcessingInstruction(zend_class_entry *class_entry_DOMNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMProcessingInstruction", class_DOMProcessingInstruction_methods); + INIT_CLASS_NAME(namespaced_name, "DOMProcessingInstruction"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMProcessingInstruction_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DOMNode, 0); zval property_target_default_value; @@ -2695,8 +2737,10 @@ static zend_class_entry *register_class_DOMProcessingInstruction(zend_class_entr static zend_class_entry *register_class_DOMXPath(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DOMXPath", class_DOMXPath_methods); + INIT_CLASS_NAME(namespaced_name, "DOMXPath"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DOMXPath_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval property_document_default_value; @@ -2719,8 +2763,10 @@ static zend_class_entry *register_class_DOMXPath(void) static zend_class_entry *register_class_Dom_ParentNode(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "ParentNode", class_Dom_ParentNode_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "ParentNode"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_ParentNode_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -2729,8 +2775,10 @@ static zend_class_entry *register_class_Dom_ParentNode(void) static zend_class_entry *register_class_Dom_ChildNode(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "ChildNode", class_Dom_ChildNode_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "ChildNode"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_ChildNode_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -2739,8 +2787,10 @@ static zend_class_entry *register_class_Dom_ChildNode(void) static zend_class_entry *register_class_Dom_Implementation(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "Implementation", class_Dom_Implementation_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "Implementation"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_Implementation_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -2749,8 +2799,10 @@ static zend_class_entry *register_class_Dom_Implementation(void) static zend_class_entry *register_class_Dom_Node(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "Node", class_Dom_Node_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "Node"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_Node_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NO_DYNAMIC_PROPERTIES); zval const_DOCUMENT_POSITION_DISCONNECTED_value; @@ -2887,8 +2939,10 @@ static zend_class_entry *register_class_Dom_Node(void) static zend_class_entry *register_class_Dom_NodeList(zend_class_entry *class_entry_IteratorAggregate, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "NodeList", class_Dom_NodeList_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "NodeList"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_NodeList_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 2, class_entry_IteratorAggregate, class_entry_Countable); @@ -2904,8 +2958,10 @@ static zend_class_entry *register_class_Dom_NodeList(zend_class_entry *class_ent static zend_class_entry *register_class_Dom_NamedNodeMap(zend_class_entry *class_entry_IteratorAggregate, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "NamedNodeMap", class_Dom_NamedNodeMap_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "NamedNodeMap"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_NamedNodeMap_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 2, class_entry_IteratorAggregate, class_entry_Countable); @@ -2921,8 +2977,10 @@ static zend_class_entry *register_class_Dom_NamedNodeMap(zend_class_entry *class static zend_class_entry *register_class_Dom_DtdNamedNodeMap(zend_class_entry *class_entry_IteratorAggregate, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "DtdNamedNodeMap", class_Dom_DtdNamedNodeMap_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "DtdNamedNodeMap"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_DtdNamedNodeMap_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 2, class_entry_IteratorAggregate, class_entry_Countable); @@ -2938,8 +2996,10 @@ static zend_class_entry *register_class_Dom_DtdNamedNodeMap(zend_class_entry *cl static zend_class_entry *register_class_Dom_HTMLCollection(zend_class_entry *class_entry_IteratorAggregate, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "HTMLCollection", class_Dom_HTMLCollection_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "HTMLCollection"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_HTMLCollection_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 2, class_entry_IteratorAggregate, class_entry_Countable); @@ -2982,8 +3042,10 @@ static zend_class_entry *register_class_Dom_AdjacentPosition(void) static zend_class_entry *register_class_Dom_Element(zend_class_entry *class_entry_Dom_Node, zend_class_entry *class_entry_Dom_ParentNode, zend_class_entry *class_entry_Dom_ChildNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "Element", class_Dom_Element_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "Element"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_Element_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Node, 0); zend_class_implements(class_entry, 2, class_entry_Dom_ParentNode, class_entry_Dom_ChildNode); @@ -3095,8 +3157,10 @@ static zend_class_entry *register_class_Dom_Element(zend_class_entry *class_entr static zend_class_entry *register_class_Dom_HTMLElement(zend_class_entry *class_entry_Dom_Element) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "HTMLElement", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "HTMLElement"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Element, 0); return class_entry; @@ -3105,8 +3169,10 @@ static zend_class_entry *register_class_Dom_HTMLElement(zend_class_entry *class_ static zend_class_entry *register_class_Dom_Attr(zend_class_entry *class_entry_Dom_Node) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "Attr", class_Dom_Attr_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "Attr"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_Attr_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Node, 0); zval property_namespaceURI_default_value; @@ -3154,8 +3220,10 @@ static zend_class_entry *register_class_Dom_Attr(zend_class_entry *class_entry_D static zend_class_entry *register_class_Dom_CharacterData(zend_class_entry *class_entry_Dom_Node, zend_class_entry *class_entry_Dom_ChildNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "CharacterData", class_Dom_CharacterData_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "CharacterData"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_CharacterData_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Node, 0); zend_class_implements(class_entry, 1, class_entry_Dom_ChildNode); @@ -3191,8 +3259,10 @@ static zend_class_entry *register_class_Dom_CharacterData(zend_class_entry *clas static zend_class_entry *register_class_Dom_Text(zend_class_entry *class_entry_Dom_CharacterData) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "Text", class_Dom_Text_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "Text"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_Text_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_CharacterData, 0); zval property_wholeText_default_value; @@ -3207,8 +3277,10 @@ static zend_class_entry *register_class_Dom_Text(zend_class_entry *class_entry_D static zend_class_entry *register_class_Dom_CDATASection(zend_class_entry *class_entry_Dom_Text) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "CDATASection", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "CDATASection"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Text, 0); return class_entry; @@ -3217,8 +3289,10 @@ static zend_class_entry *register_class_Dom_CDATASection(zend_class_entry *class static zend_class_entry *register_class_Dom_ProcessingInstruction(zend_class_entry *class_entry_Dom_CharacterData) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "ProcessingInstruction", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "ProcessingInstruction"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_CharacterData, 0); zval property_target_default_value; @@ -3233,8 +3307,10 @@ static zend_class_entry *register_class_Dom_ProcessingInstruction(zend_class_ent static zend_class_entry *register_class_Dom_Comment(zend_class_entry *class_entry_Dom_CharacterData) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "Comment", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "Comment"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_CharacterData, 0); return class_entry; @@ -3243,8 +3319,10 @@ static zend_class_entry *register_class_Dom_Comment(zend_class_entry *class_entr static zend_class_entry *register_class_Dom_DocumentType(zend_class_entry *class_entry_Dom_Node, zend_class_entry *class_entry_Dom_ChildNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "DocumentType", class_Dom_DocumentType_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "DocumentType"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_DocumentType_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Node, 0); zend_class_implements(class_entry, 1, class_entry_Dom_ChildNode); @@ -3290,8 +3368,10 @@ static zend_class_entry *register_class_Dom_DocumentType(zend_class_entry *class static zend_class_entry *register_class_Dom_DocumentFragment(zend_class_entry *class_entry_Dom_Node, zend_class_entry *class_entry_Dom_ParentNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "DocumentFragment", class_Dom_DocumentFragment_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "DocumentFragment"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_DocumentFragment_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Node, 0); zend_class_implements(class_entry, 1, class_entry_Dom_ParentNode); @@ -3321,8 +3401,10 @@ static zend_class_entry *register_class_Dom_DocumentFragment(zend_class_entry *c static zend_class_entry *register_class_Dom_Entity(zend_class_entry *class_entry_Dom_Node) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "Entity", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "Entity"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Node, 0); zval property_publicId_default_value; @@ -3349,8 +3431,10 @@ static zend_class_entry *register_class_Dom_Entity(zend_class_entry *class_entry static zend_class_entry *register_class_Dom_EntityReference(zend_class_entry *class_entry_Dom_Node) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "EntityReference", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "EntityReference"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Node, 0); return class_entry; @@ -3359,8 +3443,10 @@ static zend_class_entry *register_class_Dom_EntityReference(zend_class_entry *cl static zend_class_entry *register_class_Dom_Notation(zend_class_entry *class_entry_Dom_Node) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "Notation", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "Notation"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Node, 0); zval property_publicId_default_value; @@ -3381,8 +3467,10 @@ static zend_class_entry *register_class_Dom_Notation(zend_class_entry *class_ent static zend_class_entry *register_class_Dom_Document(zend_class_entry *class_entry_Dom_Node, zend_class_entry *class_entry_Dom_ParentNode) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "Document", class_Dom_Document_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "Document"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_Document_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Node, ZEND_ACC_ABSTRACT); zend_class_implements(class_entry, 1, class_entry_Dom_ParentNode); @@ -3483,8 +3571,10 @@ static zend_class_entry *register_class_Dom_Document(zend_class_entry *class_ent static zend_class_entry *register_class_Dom_HTMLDocument(zend_class_entry *class_entry_Dom_Document) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "HTMLDocument", class_Dom_HTMLDocument_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "HTMLDocument"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_HTMLDocument_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Document, ZEND_ACC_FINAL); return class_entry; @@ -3493,8 +3583,10 @@ static zend_class_entry *register_class_Dom_HTMLDocument(zend_class_entry *class static zend_class_entry *register_class_Dom_XMLDocument(zend_class_entry *class_entry_Dom_Document) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "XMLDocument", class_Dom_XMLDocument_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "XMLDocument"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_XMLDocument_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Dom_Document, ZEND_ACC_FINAL); zval property_xmlEncoding_default_value; @@ -3527,8 +3619,10 @@ static zend_class_entry *register_class_Dom_XMLDocument(zend_class_entry *class_ static zend_class_entry *register_class_Dom_TokenList(zend_class_entry *class_entry_IteratorAggregate, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "TokenList", class_Dom_TokenList_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "TokenList"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_TokenList_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 2, class_entry_IteratorAggregate, class_entry_Countable); @@ -3548,8 +3642,10 @@ static zend_class_entry *register_class_Dom_TokenList(zend_class_entry *class_en static zend_class_entry *register_class_Dom_NamespaceInfo(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "NamespaceInfo", class_Dom_NamespaceInfo_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "NamespaceInfo"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_NamespaceInfo_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE|ZEND_ACC_READONLY_CLASS); zval property_prefix_default_value; @@ -3578,8 +3674,10 @@ static zend_class_entry *register_class_Dom_NamespaceInfo(void) static zend_class_entry *register_class_Dom_XPath(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Dom", "XPath", class_Dom_XPath_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Dom", "XPath"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Dom_XPath_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NOT_SERIALIZABLE); zval property_document_default_value; diff --git a/ext/dom/token_list.c b/ext/dom/token_list.c index fe768e17b2e9c..6b4291fda563e 100644 --- a/ext/dom/token_list.c +++ b/ext/dom/token_list.c @@ -320,7 +320,7 @@ zval *dom_token_list_read_dimension(zend_object *object, zval *offset, int type, bool failed; zend_long index = dom_token_list_offset_convert_to_long(offset, &failed); if (UNEXPECTED(failed)) { - zend_illegal_container_offset(object->ce->name, offset, type); + zend_illegal_container_offset(object->ce->namespaced_name.name, offset, type); return NULL; } else { dom_token_list_item_read(php_dom_token_list_from_obj(object), rv, index); @@ -333,7 +333,7 @@ int dom_token_list_has_dimension(zend_object *object, zval *offset, int check_em bool failed; zend_long index = dom_token_list_offset_convert_to_long(offset, &failed); if (UNEXPECTED(failed)) { - zend_illegal_container_offset(object->ce->name, offset, BP_VAR_IS); + zend_illegal_container_offset(object->ce->namespaced_name.name, offset, BP_VAR_IS); return 0; } else { dom_token_list_object *token_list = php_dom_token_list_from_obj(object); diff --git a/ext/enchant/enchant_arginfo.h b/ext/enchant/enchant_arginfo.h index a06f713f9cedf..f5389dba9ad5f 100644 --- a/ext/enchant/enchant_arginfo.h +++ b/ext/enchant/enchant_arginfo.h @@ -229,8 +229,10 @@ static void register_enchant_symbols(int module_number) static zend_class_entry *register_class_EnchantBroker(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "EnchantBroker", NULL); + INIT_CLASS_NAME(namespaced_name, "EnchantBroker"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -239,8 +241,10 @@ static zend_class_entry *register_class_EnchantBroker(void) static zend_class_entry *register_class_EnchantDictionary(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "EnchantDictionary", NULL); + INIT_CLASS_NAME(namespaced_name, "EnchantDictionary"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/ffi/ffi_arginfo.h b/ext/ffi/ffi_arginfo.h index 563c9f8b8e8b1..108ec83972dac 100644 --- a/ext/ffi/ffi_arginfo.h +++ b/ext/ffi/ffi_arginfo.h @@ -199,8 +199,10 @@ static const zend_function_entry class_FFI_CType_methods[] = { static zend_class_entry *register_class_FFI(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "FFI", class_FFI_methods); + INIT_CLASS_NAME(namespaced_name, "FFI"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_FFI_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NOT_SERIALIZABLE); zval const___BIGGEST_ALIGNMENT___value; @@ -215,8 +217,10 @@ static zend_class_entry *register_class_FFI(void) static zend_class_entry *register_class_FFI_CData(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "FFI", "CData", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "FFI", "CData"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -225,8 +229,10 @@ static zend_class_entry *register_class_FFI_CData(void) static zend_class_entry *register_class_FFI_CType(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "FFI", "CType", class_FFI_CType_methods); + INIT_CLASS_NAME_NS(namespaced_name, "FFI", "CType"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_FFI_CType_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NOT_SERIALIZABLE); zval const_TYPE_VOID_value; @@ -465,8 +471,10 @@ static zend_class_entry *register_class_FFI_CType(void) static zend_class_entry *register_class_FFI_Exception(zend_class_entry *class_entry_Error) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "FFI", "Exception", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "FFI", "Exception"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Error, 0); return class_entry; @@ -475,8 +483,10 @@ static zend_class_entry *register_class_FFI_Exception(zend_class_entry *class_en static zend_class_entry *register_class_FFI_ParserException(zend_class_entry *class_entry_FFI_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "FFI", "ParserException", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "FFI", "ParserException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_FFI_Exception, ZEND_ACC_FINAL); return class_entry; diff --git a/ext/fileinfo/fileinfo_arginfo.h b/ext/fileinfo/fileinfo_arginfo.h index 36b9351ea1387..05cb7e132974a 100644 --- a/ext/fileinfo/fileinfo_arginfo.h +++ b/ext/fileinfo/fileinfo_arginfo.h @@ -101,8 +101,10 @@ static void register_fileinfo_symbols(int module_number) static zend_class_entry *register_class_finfo(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "finfo", class_finfo_methods); + INIT_CLASS_NAME(namespaced_name, "finfo"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_finfo_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/ftp/ftp_arginfo.h b/ext/ftp/ftp_arginfo.h index e28a549f9d670..6d7a5df29e0c4 100644 --- a/ext/ftp/ftp_arginfo.h +++ b/ext/ftp/ftp_arginfo.h @@ -294,8 +294,10 @@ static void register_ftp_symbols(int module_number) static zend_class_entry *register_class_FTP_Connection(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "FTP", "Connection", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "FTP", "Connection"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/gd/gd_arginfo.h b/ext/gd/gd_arginfo.h index 02f57e52ba940..7cd8d2549fec0 100644 --- a/ext/gd/gd_arginfo.h +++ b/ext/gd/gd_arginfo.h @@ -966,8 +966,10 @@ static void register_gd_symbols(int module_number) static zend_class_entry *register_class_GdImage(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "GdImage", NULL); + INIT_CLASS_NAME(namespaced_name, "GdImage"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -976,8 +978,10 @@ static zend_class_entry *register_class_GdImage(void) static zend_class_entry *register_class_GdFont(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "GdFont", NULL); + INIT_CLASS_NAME(namespaced_name, "GdFont"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/gmp/gmp_arginfo.h b/ext/gmp/gmp_arginfo.h index 31927d3e482bc..6f5879c51ab7a 100644 --- a/ext/gmp/gmp_arginfo.h +++ b/ext/gmp/gmp_arginfo.h @@ -331,8 +331,10 @@ static void register_gmp_symbols(int module_number) static zend_class_entry *register_class_GMP(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "GMP", class_GMP_methods); + INIT_CLASS_NAME(namespaced_name, "GMP"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_GMP_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); return class_entry; diff --git a/ext/hash/hash_arginfo.h b/ext/hash/hash_arginfo.h index 24a17fd9750b4..c0af5209aba0f 100644 --- a/ext/hash/hash_arginfo.h +++ b/ext/hash/hash_arginfo.h @@ -248,8 +248,10 @@ static void register_hash_symbols(int module_number) static zend_class_entry *register_class_HashContext(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "HashContext", class_HashContext_methods); + INIT_CLASS_NAME(namespaced_name, "HashContext"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_HashContext_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); return class_entry; diff --git a/ext/intl/breakiterator/breakiterator_arginfo.h b/ext/intl/breakiterator/breakiterator_arginfo.h index 9475f5e987fc6..4b7fac2d1134c 100644 --- a/ext/intl/breakiterator/breakiterator_arginfo.h +++ b/ext/intl/breakiterator/breakiterator_arginfo.h @@ -154,8 +154,10 @@ static const zend_function_entry class_IntlCodePointBreakIterator_methods[] = { static zend_class_entry *register_class_IntlBreakIterator(zend_class_entry *class_entry_IteratorAggregate) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlBreakIterator", class_IntlBreakIterator_methods); + INIT_CLASS_NAME(namespaced_name, "IntlBreakIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IntlBreakIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_IteratorAggregate); @@ -279,8 +281,10 @@ static zend_class_entry *register_class_IntlBreakIterator(zend_class_entry *clas static zend_class_entry *register_class_IntlRuleBasedBreakIterator(zend_class_entry *class_entry_IntlBreakIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlRuleBasedBreakIterator", class_IntlRuleBasedBreakIterator_methods); + INIT_CLASS_NAME(namespaced_name, "IntlRuleBasedBreakIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IntlRuleBasedBreakIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_IntlBreakIterator, ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -289,8 +293,10 @@ static zend_class_entry *register_class_IntlRuleBasedBreakIterator(zend_class_en static zend_class_entry *register_class_IntlCodePointBreakIterator(zend_class_entry *class_entry_IntlBreakIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlCodePointBreakIterator", class_IntlCodePointBreakIterator_methods); + INIT_CLASS_NAME(namespaced_name, "IntlCodePointBreakIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IntlCodePointBreakIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_IntlBreakIterator, ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/intl/breakiterator/breakiterator_iterators_arginfo.h b/ext/intl/breakiterator/breakiterator_iterators_arginfo.h index f83c0accf6bf4..42a6d0908999e 100644 --- a/ext/intl/breakiterator/breakiterator_iterators_arginfo.h +++ b/ext/intl/breakiterator/breakiterator_iterators_arginfo.h @@ -19,8 +19,10 @@ static const zend_function_entry class_IntlPartsIterator_methods[] = { static zend_class_entry *register_class_IntlPartsIterator(zend_class_entry *class_entry_IntlIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlPartsIterator", class_IntlPartsIterator_methods); + INIT_CLASS_NAME(namespaced_name, "IntlPartsIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IntlPartsIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_IntlIterator, ZEND_ACC_NOT_SERIALIZABLE); zval const_KEY_SEQUENTIAL_value; diff --git a/ext/intl/calendar/calendar_arginfo.h b/ext/intl/calendar/calendar_arginfo.h index 9e050539b2e87..c14e31ec4d77a 100644 --- a/ext/intl/calendar/calendar_arginfo.h +++ b/ext/intl/calendar/calendar_arginfo.h @@ -323,8 +323,10 @@ static const zend_function_entry class_IntlGregorianCalendar_methods[] = { static zend_class_entry *register_class_IntlCalendar(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlCalendar", class_IntlCalendar_methods); + INIT_CLASS_NAME(namespaced_name, "IntlCalendar"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IntlCalendar_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval const_FIELD_ERA_value; @@ -567,8 +569,10 @@ static zend_class_entry *register_class_IntlCalendar(void) static zend_class_entry *register_class_IntlGregorianCalendar(zend_class_entry *class_entry_IntlCalendar) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlGregorianCalendar", class_IntlGregorianCalendar_methods); + INIT_CLASS_NAME(namespaced_name, "IntlGregorianCalendar"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IntlGregorianCalendar_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_IntlCalendar, ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/intl/collator/collator_arginfo.h b/ext/intl/collator/collator_arginfo.h index 3f469b02facd4..ef264509edc96 100644 --- a/ext/intl/collator/collator_arginfo.h +++ b/ext/intl/collator/collator_arginfo.h @@ -97,8 +97,10 @@ static void register_collator_symbols(int module_number) static zend_class_entry *register_class_Collator(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Collator", class_Collator_methods); + INIT_CLASS_NAME(namespaced_name, "Collator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Collator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval const_DEFAULT_VALUE_value; diff --git a/ext/intl/common/common_arginfo.h b/ext/intl/common/common_arginfo.h index c5e023ecb8883..f147a253a54c6 100644 --- a/ext/intl/common/common_arginfo.h +++ b/ext/intl/common/common_arginfo.h @@ -177,8 +177,10 @@ static void register_common_symbols(int module_number) static zend_class_entry *register_class_IntlIterator(zend_class_entry *class_entry_Iterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlIterator", class_IntlIterator_methods); + INIT_CLASS_NAME(namespaced_name, "IntlIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IntlIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Iterator); diff --git a/ext/intl/common/common_date.cpp b/ext/intl/common/common_date.cpp index e4f442a8195ad..4639ad30c0b51 100644 --- a/ext/intl/common/common_date.cpp +++ b/ext/intl/common/common_date.cpp @@ -124,7 +124,7 @@ U_CFUNC zend_result intl_datetime_decompose(zend_object *obj, double *millis, Ti } // TODO: Remove this when DateTimeInterface::getTimestamp() no longer has a tentative return type if (Z_TYPE(retval) != IS_LONG) { - spprintf(&message, 0, "%s: %s::getTimestamp() did not return an int", func, ZSTR_VAL(obj->ce->name)); + spprintf(&message, 0, "%s: %s::getTimestamp() did not return an int", func, ZSTR_VAL(obj->ce->namespaced_name.name)); intl_errors_set(err, U_INTERNAL_PROGRAM_ERROR, message, 1); efree(message); return FAILURE; @@ -136,7 +136,7 @@ U_CFUNC zend_result intl_datetime_decompose(zend_object *obj, double *millis, Ti if (tz) { if (!datetime->time) { spprintf(&message, 0, "%s: the %s object is not properly " - "initialized", func, ZSTR_VAL(obj->ce->name)); + "initialized", func, ZSTR_VAL(obj->ce->namespaced_name.name)); intl_errors_set(err, U_ILLEGAL_ARGUMENT_ERROR, message, 1); efree(message); diff --git a/ext/intl/converter/converter_arginfo.h b/ext/intl/converter/converter_arginfo.h index 4e02daf9478ad..d44cfaf659fda 100644 --- a/ext/intl/converter/converter_arginfo.h +++ b/ext/intl/converter/converter_arginfo.h @@ -120,8 +120,10 @@ static const zend_function_entry class_UConverter_methods[] = { static zend_class_entry *register_class_UConverter(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "UConverter", class_UConverter_methods); + INIT_CLASS_NAME(namespaced_name, "UConverter"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_UConverter_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval const_REASON_UNASSIGNED_value; diff --git a/ext/intl/dateformat/dateformat_arginfo.h b/ext/intl/dateformat/dateformat_arginfo.h index b57cb79468f2b..0f48e906aca2f 100644 --- a/ext/intl/dateformat/dateformat_arginfo.h +++ b/ext/intl/dateformat/dateformat_arginfo.h @@ -143,8 +143,10 @@ static const zend_function_entry class_IntlDateFormatter_methods[] = { static zend_class_entry *register_class_IntlDateFormatter(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlDateFormatter", class_IntlDateFormatter_methods); + INIT_CLASS_NAME(namespaced_name, "IntlDateFormatter"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IntlDateFormatter_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval const_FULL_value; diff --git a/ext/intl/dateformat/datepatterngenerator_arginfo.h b/ext/intl/dateformat/datepatterngenerator_arginfo.h index 14327b0d69f88..d10aca45ee9c9 100644 --- a/ext/intl/dateformat/datepatterngenerator_arginfo.h +++ b/ext/intl/dateformat/datepatterngenerator_arginfo.h @@ -27,8 +27,10 @@ static const zend_function_entry class_IntlDatePatternGenerator_methods[] = { static zend_class_entry *register_class_IntlDatePatternGenerator(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlDatePatternGenerator", class_IntlDatePatternGenerator_methods); + INIT_CLASS_NAME(namespaced_name, "IntlDatePatternGenerator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IntlDatePatternGenerator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/intl/formatter/formatter_arginfo.h b/ext/intl/formatter/formatter_arginfo.h index c7fd28c3a9f77..1dfe9040cbd55 100644 --- a/ext/intl/formatter/formatter_arginfo.h +++ b/ext/intl/formatter/formatter_arginfo.h @@ -121,8 +121,10 @@ static const zend_function_entry class_NumberFormatter_methods[] = { static zend_class_entry *register_class_NumberFormatter(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "NumberFormatter", class_NumberFormatter_methods); + INIT_CLASS_NAME(namespaced_name, "NumberFormatter"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_NumberFormatter_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval const_PATTERN_DECIMAL_value; diff --git a/ext/intl/locale/locale_arginfo.h b/ext/intl/locale/locale_arginfo.h index 7bba882d20457..5f6cd6b5f6a40 100644 --- a/ext/intl/locale/locale_arginfo.h +++ b/ext/intl/locale/locale_arginfo.h @@ -106,8 +106,10 @@ static const zend_function_entry class_Locale_methods[] = { static zend_class_entry *register_class_Locale(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Locale", class_Locale_methods); + INIT_CLASS_NAME(namespaced_name, "Locale"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Locale_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval const_ACTUAL_LOCALE_value; diff --git a/ext/intl/msgformat/msgformat_arginfo.h b/ext/intl/msgformat/msgformat_arginfo.h index 74353fbf93ae2..d69a80b7af8b5 100644 --- a/ext/intl/msgformat/msgformat_arginfo.h +++ b/ext/intl/msgformat/msgformat_arginfo.h @@ -76,8 +76,10 @@ static const zend_function_entry class_MessageFormatter_methods[] = { static zend_class_entry *register_class_MessageFormatter(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "MessageFormatter", class_MessageFormatter_methods); + INIT_CLASS_NAME(namespaced_name, "MessageFormatter"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_MessageFormatter_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/intl/normalizer/normalizer_arginfo.h b/ext/intl/normalizer/normalizer_arginfo.h index e5ef152c0423a..9a99921a1a56a 100644 --- a/ext/intl/normalizer/normalizer_arginfo.h +++ b/ext/intl/normalizer/normalizer_arginfo.h @@ -30,8 +30,10 @@ static const zend_function_entry class_Normalizer_methods[] = { static zend_class_entry *register_class_Normalizer(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Normalizer", class_Normalizer_methods); + INIT_CLASS_NAME(namespaced_name, "Normalizer"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Normalizer_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval const_FORM_D_value; diff --git a/ext/intl/php_intl_arginfo.h b/ext/intl/php_intl_arginfo.h index 11c585d8df63b..b48390542c3ee 100644 --- a/ext/intl/php_intl_arginfo.h +++ b/ext/intl/php_intl_arginfo.h @@ -1224,8 +1224,10 @@ static void register_php_intl_symbols(int module_number) static zend_class_entry *register_class_IntlException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlException", NULL); + INIT_CLASS_NAME(namespaced_name, "IntlException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, 0); return class_entry; diff --git a/ext/intl/resourcebundle/resourcebundle_arginfo.h b/ext/intl/resourcebundle/resourcebundle_arginfo.h index f52de6314aa5d..213387d13b39c 100644 --- a/ext/intl/resourcebundle/resourcebundle_arginfo.h +++ b/ext/intl/resourcebundle/resourcebundle_arginfo.h @@ -57,8 +57,10 @@ static const zend_function_entry class_ResourceBundle_methods[] = { static zend_class_entry *register_class_ResourceBundle(zend_class_entry *class_entry_IteratorAggregate, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ResourceBundle", class_ResourceBundle_methods); + INIT_CLASS_NAME(namespaced_name, "ResourceBundle"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ResourceBundle_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 2, class_entry_IteratorAggregate, class_entry_Countable); diff --git a/ext/intl/resourcebundle/resourcebundle_class.c b/ext/intl/resourcebundle/resourcebundle_class.c index c64bf1d451849..25a389e29247c 100644 --- a/ext/intl/resourcebundle/resourcebundle_class.c +++ b/ext/intl/resourcebundle/resourcebundle_class.c @@ -253,7 +253,7 @@ zval *resourcebundle_array_get(zend_object *object, zval *offset, int type, zval } else if (Z_TYPE_P(offset) == IS_STRING) { return resource_bundle_array_fetch(object, Z_STR_P(offset), /* offset_int */ 0, rv, /* fallback */ true, /* arg_num */ 0); } else { - zend_illegal_container_offset(object->ce->name, offset, type); + zend_illegal_container_offset(object->ce->namespaced_name.name, offset, type); return NULL; } } diff --git a/ext/intl/spoofchecker/spoofchecker_arginfo.h b/ext/intl/spoofchecker/spoofchecker_arginfo.h index cee17335dcd40..c0737bcff7ed1 100644 --- a/ext/intl/spoofchecker/spoofchecker_arginfo.h +++ b/ext/intl/spoofchecker/spoofchecker_arginfo.h @@ -60,8 +60,10 @@ static const zend_function_entry class_Spoofchecker_methods[] = { static zend_class_entry *register_class_Spoofchecker(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Spoofchecker", class_Spoofchecker_methods); + INIT_CLASS_NAME(namespaced_name, "Spoofchecker"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Spoofchecker_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval const_SINGLE_SCRIPT_CONFUSABLE_value; diff --git a/ext/intl/timezone/timezone_arginfo.h b/ext/intl/timezone/timezone_arginfo.h index 6206e03efad3e..204e5aa64005a 100644 --- a/ext/intl/timezone/timezone_arginfo.h +++ b/ext/intl/timezone/timezone_arginfo.h @@ -162,8 +162,10 @@ static const zend_function_entry class_IntlTimeZone_methods[] = { static zend_class_entry *register_class_IntlTimeZone(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlTimeZone", class_IntlTimeZone_methods); + INIT_CLASS_NAME(namespaced_name, "IntlTimeZone"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IntlTimeZone_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval const_DISPLAY_SHORT_value; diff --git a/ext/intl/transliterator/transliterator_arginfo.h b/ext/intl/transliterator/transliterator_arginfo.h index 0a53fe9a6b9c4..f651926e4a210 100644 --- a/ext/intl/transliterator/transliterator_arginfo.h +++ b/ext/intl/transliterator/transliterator_arginfo.h @@ -56,8 +56,10 @@ static const zend_function_entry class_Transliterator_methods[] = { static zend_class_entry *register_class_Transliterator(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Transliterator", class_Transliterator_methods); + INIT_CLASS_NAME(namespaced_name, "Transliterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Transliterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval const_FORWARD_value; diff --git a/ext/intl/uchar/uchar_arginfo.h b/ext/intl/uchar/uchar_arginfo.h index 085b3b0a5eff3..063152950cda4 100644 --- a/ext/intl/uchar/uchar_arginfo.h +++ b/ext/intl/uchar/uchar_arginfo.h @@ -304,8 +304,10 @@ static const zend_function_entry class_IntlChar_methods[] = { static zend_class_entry *register_class_IntlChar(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IntlChar", class_IntlChar_methods); + INIT_CLASS_NAME(namespaced_name, "IntlChar"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IntlChar_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval const_UNICODE_VERSION_value; diff --git a/ext/json/json_arginfo.h b/ext/json/json_arginfo.h index 6b1eb0f1a50a3..d3b766917c11d 100644 --- a/ext/json/json_arginfo.h +++ b/ext/json/json_arginfo.h @@ -85,8 +85,10 @@ static void register_json_symbols(int module_number) static zend_class_entry *register_class_JsonSerializable(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "JsonSerializable", class_JsonSerializable_methods); + INIT_CLASS_NAME(namespaced_name, "JsonSerializable"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_JsonSerializable_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -95,8 +97,10 @@ static zend_class_entry *register_class_JsonSerializable(void) static zend_class_entry *register_class_JsonException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "JsonException", NULL); + INIT_CLASS_NAME(namespaced_name, "JsonException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, 0); return class_entry; diff --git a/ext/ldap/ldap_arginfo.h b/ext/ldap/ldap_arginfo.h index 01e08540142b4..0f6d9bece6480 100644 --- a/ext/ldap/ldap_arginfo.h +++ b/ext/ldap/ldap_arginfo.h @@ -830,8 +830,10 @@ static void register_ldap_symbols(int module_number) static zend_class_entry *register_class_LDAP_Connection(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "LDAP", "Connection", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "LDAP", "Connection"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -840,8 +842,10 @@ static zend_class_entry *register_class_LDAP_Connection(void) static zend_class_entry *register_class_LDAP_Result(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "LDAP", "Result", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "LDAP", "Result"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -850,8 +854,10 @@ static zend_class_entry *register_class_LDAP_Result(void) static zend_class_entry *register_class_LDAP_ResultEntry(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "LDAP", "ResultEntry", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "LDAP", "ResultEntry"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/libxml/libxml.c b/ext/libxml/libxml.c index 94704d09e463e..5058cb1e5d6c0 100644 --- a/ext/libxml/libxml.c +++ b/ext/libxml/libxml.c @@ -1275,7 +1275,7 @@ zval *php_libxml_register_export(zend_class_entry *ce, php_libxml_export_node ex php_libxml_initialize(); export_hnd.export_func = export_function; - return zend_hash_add_mem(&php_libxml_exports, ce->name, &export_hnd, sizeof(export_hnd)); + return zend_hash_add_mem(&php_libxml_exports, ce->namespaced_name.name, &export_hnd, sizeof(export_hnd)); } PHP_LIBXML_API xmlNodePtr php_libxml_import_node(zval *object) @@ -1289,7 +1289,7 @@ PHP_LIBXML_API xmlNodePtr php_libxml_import_node(zval *object) while (ce->parent != NULL) { ce = ce->parent; } - if ((export_hnd = zend_hash_find_ptr(&php_libxml_exports, ce->name))) { + if ((export_hnd = zend_hash_find_ptr(&php_libxml_exports, ce->namespaced_name.name))) { node = export_hnd->export_func(object); } } diff --git a/ext/libxml/libxml_arginfo.h b/ext/libxml/libxml_arginfo.h index 86336d09c7d1b..fad2f744eb447 100644 --- a/ext/libxml/libxml_arginfo.h +++ b/ext/libxml/libxml_arginfo.h @@ -103,8 +103,10 @@ static void register_libxml_symbols(int module_number) static zend_class_entry *register_class_LibXMLError(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "LibXMLError", NULL); + INIT_CLASS_NAME(namespaced_name, "LibXMLError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_level_default_value; diff --git a/ext/mysqli/mysqli.c b/ext/mysqli/mysqli.c index 987183aa9dcb0..d037558ec4e45 100644 --- a/ext/mysqli/mysqli.c +++ b/ext/mysqli/mysqli.c @@ -265,7 +265,7 @@ zval *mysqli_write_property(zend_object *object, zend_string *name, zval *value, if (hnd) { if (!hnd->write_func) { zend_throw_error(NULL, "Cannot write read-only property %s::$%s", - ZSTR_VAL(object->ce->name), ZSTR_VAL(name)); + ZSTR_VAL(object->ce->namespaced_name.name), ZSTR_VAL(name)); return &EG(error_zval); } @@ -376,7 +376,7 @@ PHP_MYSQLI_EXPORT(zend_object *) mysqli_objects_new(zend_class_entry *class_type mysqli_base_class->parent != NULL) { mysqli_base_class = mysqli_base_class->parent; } - intern->prop_handler = zend_hash_find_ptr(&classes, mysqli_base_class->name); + intern->prop_handler = zend_hash_find_ptr(&classes, mysqli_base_class->namespaced_name.name); zend_object_std_init(&intern->zo, class_type); object_properties_init(&intern->zo, class_type); @@ -411,7 +411,7 @@ static MYSQLND *mysqli_convert_zv_to_mysqlnd(zval * zv) mysqli_object *intern = Z_MYSQLI_P(zv); if (!(my_res = (MYSQLI_RESOURCE *)intern->ptr)) { /* We know that we have a mysqli object, so this failure should be emitted */ - zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(intern->zo.ce->name)); + zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(intern->zo.ce->namespaced_name.name)); return NULL; } mysql = (MY_MYSQL *)(my_res->ptr); @@ -505,32 +505,32 @@ PHP_MINIT_FUNCTION(mysqli) mysqli_driver_class_entry->create_object = mysqli_objects_new; zend_hash_init(&mysqli_driver_properties, 0, NULL, free_prop_handler, 1); MYSQLI_ADD_PROPERTIES(&mysqli_driver_properties, mysqli_driver_property_entries); - zend_hash_add_ptr(&classes, mysqli_driver_class_entry->name, &mysqli_driver_properties); + zend_hash_add_ptr(&classes, mysqli_driver_class_entry->namespaced_name.name, &mysqli_driver_properties); mysqli_link_class_entry = register_class_mysqli(); mysqli_link_class_entry->create_object = mysqli_objects_new; zend_hash_init(&mysqli_link_properties, 0, NULL, free_prop_handler, 1); MYSQLI_ADD_PROPERTIES(&mysqli_link_properties, mysqli_link_property_entries); - zend_hash_add_ptr(&classes, mysqli_link_class_entry->name, &mysqli_link_properties); + zend_hash_add_ptr(&classes, mysqli_link_class_entry->namespaced_name.name, &mysqli_link_properties); mysqli_warning_class_entry = register_class_mysqli_warning(); mysqli_warning_class_entry->create_object = mysqli_objects_new; zend_hash_init(&mysqli_warning_properties, 0, NULL, free_prop_handler, 1); MYSQLI_ADD_PROPERTIES(&mysqli_warning_properties, mysqli_warning_property_entries); - zend_hash_add_ptr(&classes, mysqli_warning_class_entry->name, &mysqli_warning_properties); + zend_hash_add_ptr(&classes, mysqli_warning_class_entry->namespaced_name.name, &mysqli_warning_properties); mysqli_result_class_entry = register_class_mysqli_result(zend_ce_aggregate); mysqli_result_class_entry->create_object = mysqli_objects_new; mysqli_result_class_entry->get_iterator = php_mysqli_result_get_iterator; zend_hash_init(&mysqli_result_properties, 0, NULL, free_prop_handler, 1); MYSQLI_ADD_PROPERTIES(&mysqli_result_properties, mysqli_result_property_entries); - zend_hash_add_ptr(&classes, mysqli_result_class_entry->name, &mysqli_result_properties); + zend_hash_add_ptr(&classes, mysqli_result_class_entry->namespaced_name.name, &mysqli_result_properties); mysqli_stmt_class_entry = register_class_mysqli_stmt(); mysqli_stmt_class_entry->create_object = mysqli_objects_new; zend_hash_init(&mysqli_stmt_properties, 0, NULL, free_prop_handler, 1); MYSQLI_ADD_PROPERTIES(&mysqli_stmt_properties, mysqli_stmt_property_entries); - zend_hash_add_ptr(&classes, mysqli_stmt_class_entry->name, &mysqli_stmt_properties); + zend_hash_add_ptr(&classes, mysqli_stmt_class_entry->namespaced_name.name, &mysqli_stmt_properties); register_mysqli_symbols(module_number); @@ -759,7 +759,7 @@ void php_mysqli_fetch_into_hash(INTERNAL_FUNCTION_PARAMETERS, int override_flags ce = zend_standard_class_def; } if (UNEXPECTED(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))) { - zend_throw_error(NULL, "Class %s cannot be instantiated", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "Class %s cannot be instantiated", ZSTR_VAL(ce->namespaced_name.name)); RETURN_THROWS(); } fetchtype = MYSQLI_ASSOC; @@ -806,7 +806,7 @@ void php_mysqli_fetch_into_hash(INTERNAL_FUNCTION_PARAMETERS, int override_flags } else if (ctor_params && zend_hash_num_elements(ctor_params) > 0) { zend_argument_value_error(ERROR_ARG_POS(3), "must be empty when the specified class (%s) does not have a constructor", - ZSTR_VAL(ce->name) + ZSTR_VAL(ce->namespaced_name.name) ); } } diff --git a/ext/mysqli/mysqli_arginfo.h b/ext/mysqli/mysqli_arginfo.h index 4e624d623d807..7326b8af90f19 100644 --- a/ext/mysqli/mysqli_arginfo.h +++ b/ext/mysqli/mysqli_arginfo.h @@ -1192,8 +1192,10 @@ static void register_mysqli_symbols(int module_number) static zend_class_entry *register_class_mysqli_driver(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "mysqli_driver", NULL); + INIT_CLASS_NAME(namespaced_name, "mysqli_driver"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zval property_client_info_default_value; @@ -1226,8 +1228,10 @@ static zend_class_entry *register_class_mysqli_driver(void) static zend_class_entry *register_class_mysqli(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "mysqli", class_mysqli_methods); + INIT_CLASS_NAME(namespaced_name, "mysqli"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_mysqli_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_affected_rows_default_value; @@ -1413,8 +1417,10 @@ static zend_class_entry *register_class_mysqli(void) static zend_class_entry *register_class_mysqli_result(zend_class_entry *class_entry_IteratorAggregate) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "mysqli_result", class_mysqli_result_methods); + INIT_CLASS_NAME(namespaced_name, "mysqli_result"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_mysqli_result_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_IteratorAggregate); @@ -1452,8 +1458,10 @@ static zend_class_entry *register_class_mysqli_result(zend_class_entry *class_en static zend_class_entry *register_class_mysqli_stmt(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "mysqli_stmt", class_mysqli_stmt_methods); + INIT_CLASS_NAME(namespaced_name, "mysqli_stmt"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_mysqli_stmt_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_affected_rows_default_value; @@ -1522,8 +1530,10 @@ static zend_class_entry *register_class_mysqli_stmt(void) static zend_class_entry *register_class_mysqli_warning(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "mysqli_warning", class_mysqli_warning_methods); + INIT_CLASS_NAME(namespaced_name, "mysqli_warning"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_mysqli_warning_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zval property_message_default_value; @@ -1548,8 +1558,10 @@ static zend_class_entry *register_class_mysqli_warning(void) static zend_class_entry *register_class_mysqli_sql_exception(zend_class_entry *class_entry_RuntimeException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "mysqli_sql_exception", class_mysqli_sql_exception_methods); + INIT_CLASS_NAME(namespaced_name, "mysqli_sql_exception"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_mysqli_sql_exception_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RuntimeException, ZEND_ACC_FINAL); zval property_sqlstate_default_value; diff --git a/ext/mysqli/mysqli_nonapi.c b/ext/mysqli/mysqli_nonapi.c index e0e14eeccbc92..ebfb758b57f95 100644 --- a/ext/mysqli/mysqli_nonapi.c +++ b/ext/mysqli/mysqli_nonapi.c @@ -666,12 +666,12 @@ static zend_result mysqlnd_zval_array_to_mysqlnd_array(zval *in_array, MYSQLND * MYSQLI_RESOURCE *my_res; mysqli_object *intern = Z_MYSQLI_P(elem); if (!(my_res = (MYSQLI_RESOURCE *)intern->ptr)) { - zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(intern->zo.ce->name)); + zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(intern->zo.ce->namespaced_name.name)); return FAILURE; } mysql = (MY_MYSQL*) my_res->ptr; if (my_res->status < MYSQLI_STATUS_VALID) { - zend_throw_error(NULL, "%s object is not fully initialized", ZSTR_VAL(intern->zo.ce->name)); + zend_throw_error(NULL, "%s object is not fully initialized", ZSTR_VAL(intern->zo.ce->namespaced_name.name)); return FAILURE; } (*out_array)[current++] = mysql->mysql; @@ -700,7 +700,7 @@ static zend_result mysqlnd_zval_array_from_mysqlnd_array(MYSQLND **in_array, zva MYSQLI_RESOURCE *my_res; mysqli_object *intern = Z_MYSQLI_P(elem); if (!(my_res = (MYSQLI_RESOURCE *)intern->ptr)) { - zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(intern->zo.ce->name)); + zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(intern->zo.ce->namespaced_name.name)); return FAILURE; } mysql = (MY_MYSQL *) my_res->ptr; diff --git a/ext/mysqli/mysqli_prop.c b/ext/mysqli/mysqli_prop.c index 6d86a6ad4ca8b..1b033bd0dd93f 100644 --- a/ext/mysqli/mysqli_prop.c +++ b/ext/mysqli/mysqli_prop.c @@ -37,7 +37,7 @@ MYSQL *p; \ if (!obj->ptr || !(MY_MYSQL *)((MYSQLI_RESOURCE *)(obj->ptr))->ptr) { \ if (!quiet) { \ - zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->name)); \ + zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->namespaced_name.name)); \ } \ return FAILURE; \ } else { \ @@ -49,7 +49,7 @@ if (!obj->ptr || !(MY_MYSQL *)((MYSQLI_RESOURCE *)(obj->ptr))->ptr) { \ MYSQL_RES *p; \ if (!obj->ptr) { \ if (!quiet) { \ - zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->name)); \ + zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->namespaced_name.name)); \ } \ return FAILURE; \ } else { \ @@ -61,7 +61,7 @@ if (!obj->ptr) { \ MYSQL_STMT *p; \ if (!obj->ptr) { \ if (!quiet) { \ - zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->name)); \ + zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->namespaced_name.name)); \ } \ return FAILURE; \ } else { \ diff --git a/ext/mysqli/mysqli_warning.c b/ext/mysqli/mysqli_warning.c index b1427495a5066..82a2d7576c747 100644 --- a/ext/mysqli/mysqli_warning.c +++ b/ext/mysqli/mysqli_warning.c @@ -144,7 +144,7 @@ static zend_result mysqli_warning_message(mysqli_object *obj, zval *retval, bool if (!obj->ptr || !((MYSQLI_RESOURCE *)(obj->ptr))->ptr) { if (!quiet) { - zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->name)); + zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->namespaced_name.name)); } return FAILURE; @@ -164,7 +164,7 @@ static zend_result mysqli_warning_sqlstate(mysqli_object *obj, zval *retval, boo if (!obj->ptr || !((MYSQLI_RESOURCE *)(obj->ptr))->ptr) { if (!quiet) { - zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->name)); + zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->namespaced_name.name)); } return FAILURE; @@ -184,7 +184,7 @@ static zend_result mysqli_warning_errno(mysqli_object *obj, zval *retval, bool q if (!obj->ptr || !((MYSQLI_RESOURCE *)(obj->ptr))->ptr) { if (!quiet) { - zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->name)); + zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(obj->zo.ce->namespaced_name.name)); } return FAILURE; diff --git a/ext/mysqli/php_mysqli_structs.h b/ext/mysqli/php_mysqli_structs.h index c155281c8e4bc..4a9fc41330523 100644 --- a/ext/mysqli/php_mysqli_structs.h +++ b/ext/mysqli/php_mysqli_structs.h @@ -182,12 +182,12 @@ extern void php_mysqli_fetch_into_hash_aux(zval *return_value, MYSQL_RES * resul MYSQLI_RESOURCE *my_res; \ mysqli_object *intern = Z_MYSQLI_P(__id); \ if (!(my_res = (MYSQLI_RESOURCE *)intern->ptr)) {\ - zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(intern->zo.ce->name));\ + zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(intern->zo.ce->namespaced_name.name));\ RETURN_THROWS();\ }\ __ptr = (__type)my_res->ptr; \ if (my_res->status < __check) { \ - zend_throw_error(NULL, "%s object is not fully initialized", ZSTR_VAL(intern->zo.ce->name)); \ + zend_throw_error(NULL, "%s object is not fully initialized", ZSTR_VAL(intern->zo.ce->namespaced_name.name)); \ RETURN_THROWS();\ }\ } @@ -196,12 +196,12 @@ extern void php_mysqli_fetch_into_hash_aux(zval *return_value, MYSQL_RES * resul { \ MYSQLI_RESOURCE *my_res; \ if (!(my_res = (MYSQLI_RESOURCE *)(__obj->ptr))) {\ - zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(intern->zo.ce->name));\ + zend_throw_error(NULL, "%s object is already closed", ZSTR_VAL(intern->zo.ce->namespaced_name.name));\ return;\ }\ __ptr = (__type)my_res->ptr; \ if (my_res->status < __check) { \ - zend_throw_error(NULL, "%s object is not fully initialized", ZSTR_VAL(intern->zo.ce->name)); \ + zend_throw_error(NULL, "%s object is not fully initialized", ZSTR_VAL(intern->zo.ce->namespaced_name.name)); \ return;\ }\ } @@ -210,7 +210,7 @@ extern void php_mysqli_fetch_into_hash_aux(zval *return_value, MYSQL_RES * resul { \ MYSQLI_FETCH_RESOURCE((__ptr), MY_MYSQL *, (__id), "mysqli_link", (__check)); \ if (!(__ptr)->mysql) { \ - zend_throw_error(NULL, "%s object is not fully initialized", ZSTR_VAL(Z_OBJCE_P(__id)->name)); \ + zend_throw_error(NULL, "%s object is not fully initialized", ZSTR_VAL(Z_OBJCE_P(__id)->namespaced_name.name)); \ RETURN_THROWS(); \ } \ } diff --git a/ext/odbc/odbc_arginfo.h b/ext/odbc/odbc_arginfo.h index 91df4da846d49..3181db42ca921 100644 --- a/ext/odbc/odbc_arginfo.h +++ b/ext/odbc/odbc_arginfo.h @@ -476,8 +476,10 @@ static void register_odbc_symbols(int module_number) static zend_class_entry *register_class_Odbc_Connection(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Odbc", "Connection", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Odbc", "Connection"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -486,8 +488,10 @@ static zend_class_entry *register_class_Odbc_Connection(void) static zend_class_entry *register_class_Odbc_Result(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Odbc", "Result", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Odbc", "Result"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index 3d45c63a98781..771101462b510 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -1121,6 +1121,27 @@ zend_class_entry *zend_persist_class_entry(zend_class_entry *orig_ce) return ce; } +void zend_update_required_scope(zend_class_entry *ce) +{ + if (ce->required_scope) { + zend_class_entry *required_scope = ce->required_scope; + + zend_class_entry *r = zend_shared_alloc_get_xlat_entry(required_scope); + if (r) { + ce->required_scope = r; + } + } + + if (ce->lexical_scope) { + zend_class_entry *lexical_scope = ce->lexical_scope; + + zend_class_entry *l = zend_shared_alloc_get_xlat_entry(lexical_scope); + if (l) { + ce->lexical_scope = l; + } + } +} + void zend_update_parent_ce(zend_class_entry *ce) { if (ce->ce_flags & ZEND_ACC_LINKED) { @@ -1294,6 +1315,7 @@ static void zend_accel_persist_class_table(HashTable *class_table) if (EXPECTED(Z_TYPE(p->val) != IS_ALIAS_PTR)) { ce = Z_PTR(p->val); zend_update_parent_ce(ce); + zend_update_required_scope(ce); } } ZEND_HASH_FOREACH_END(); #ifdef HAVE_JIT diff --git a/ext/openssl/openssl_arginfo.h b/ext/openssl/openssl_arginfo.h index 04d7c4163db9d..2a7d4aed9a542 100644 --- a/ext/openssl/openssl_arginfo.h +++ b/ext/openssl/openssl_arginfo.h @@ -780,8 +780,10 @@ static void register_openssl_symbols(int module_number) static zend_class_entry *register_class_OpenSSLCertificate(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "OpenSSLCertificate", NULL); + INIT_CLASS_NAME(namespaced_name, "OpenSSLCertificate"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -790,8 +792,10 @@ static zend_class_entry *register_class_OpenSSLCertificate(void) static zend_class_entry *register_class_OpenSSLCertificateSigningRequest(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "OpenSSLCertificateSigningRequest", NULL); + INIT_CLASS_NAME(namespaced_name, "OpenSSLCertificateSigningRequest"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -800,8 +804,10 @@ static zend_class_entry *register_class_OpenSSLCertificateSigningRequest(void) static zend_class_entry *register_class_OpenSSLAsymmetricKey(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "OpenSSLAsymmetricKey", NULL); + INIT_CLASS_NAME(namespaced_name, "OpenSSLAsymmetricKey"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/pdo/pdo_arginfo.h b/ext/pdo/pdo_arginfo.h index d2df2f0b0eb23..7d378ea594a6b 100644 --- a/ext/pdo/pdo_arginfo.h +++ b/ext/pdo/pdo_arginfo.h @@ -14,8 +14,10 @@ static const zend_function_entry ext_functions[] = { static zend_class_entry *register_class_PDOException(zend_class_entry *class_entry_RuntimeException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "PDOException", NULL); + INIT_CLASS_NAME(namespaced_name, "PDOException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RuntimeException, 0); zval property_code_default_value; diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c index 9588f23d420c5..bbcfdbef46550 100644 --- a/ext/pdo/pdo_dbh.c +++ b/ext/pdo/pdo_dbh.c @@ -242,10 +242,10 @@ static bool create_driver_specific_pdo_object(pdo_driver_t *driver, zend_class_e zend_throw_exception_ex(pdo_exception_ce, 0, "%s::%s() cannot be used for connecting to the \"%s\" driver, " "either call %s::%s() or PDO::%s() instead", - ZSTR_VAL(called_scope->name), + ZSTR_VAL(called_scope->namespaced_name.name), new_zval_object ? "connect" : "__construct", driver->driver_name, - ZSTR_VAL(ce_based_on_driver_name->name), + ZSTR_VAL(ce_based_on_driver_name->namespaced_name.name), new_zval_object ? "connect" : "__construct", new_zval_object ? "connect" : "__construct" ); @@ -261,7 +261,7 @@ static bool create_driver_specific_pdo_object(pdo_driver_t *driver, zend_class_e zend_throw_exception_ex(pdo_exception_ce, 0, "%s::%s() cannot be used for connecting to an unknown driver, " "call PDO::%s() instead", - ZSTR_VAL(called_scope->name), + ZSTR_VAL(called_scope->namespaced_name.name), new_zval_object ? "connect" : "__construct", new_zval_object ? "connect" : "__construct" ); @@ -280,10 +280,10 @@ static bool create_driver_specific_pdo_object(pdo_driver_t *driver, zend_class_e zend_throw_exception_ex(pdo_exception_ce, 0, "%s::%s() cannot be used for connecting to the \"%s\" driver, " "either call %s::%s() or PDO::%s() instead", - ZSTR_VAL(called_scope->name), + ZSTR_VAL(called_scope->namespaced_name.name), new_zval_object ? "connect" : "__construct", driver->driver_name, - ZSTR_VAL(ce_based_on_driver_name->name), + ZSTR_VAL(ce_based_on_driver_name->namespaced_name.name), new_zval_object ? "connect" : "__construct", new_zval_object ? "connect" : "__construct" ); @@ -1012,7 +1012,7 @@ PHP_METHOD(PDO, getAttribute) case PDO_ATTR_STATEMENT_CLASS: array_init(return_value); - add_next_index_str(return_value, zend_string_copy(dbh->def_stmt_ce->name)); + add_next_index_str(return_value, zend_string_copy(dbh->def_stmt_ce->namespaced_name.name)); if (!Z_ISUNDEF(dbh->def_stmt_ctor_args)) { Z_TRY_ADDREF(dbh->def_stmt_ctor_args); add_next_index_zval(return_value, &dbh->def_stmt_ctor_args); diff --git a/ext/pdo/pdo_dbh_arginfo.h b/ext/pdo/pdo_dbh_arginfo.h index 71df4c519e1a7..6921120c4db7d 100644 --- a/ext/pdo/pdo_dbh_arginfo.h +++ b/ext/pdo/pdo_dbh_arginfo.h @@ -105,8 +105,10 @@ static const zend_function_entry class_PDO_methods[] = { static zend_class_entry *register_class_PDO(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "PDO", class_PDO_methods); + INIT_CLASS_NAME(namespaced_name, "PDO"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_PDO_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval const_PARAM_NULL_value; diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c index 942d2c2368d1d..cbac428db9b6e 100644 --- a/ext/pdo/pdo_stmt.c +++ b/ext/pdo/pdo_stmt.c @@ -37,7 +37,7 @@ #define PHP_STMT_GET_OBJ \ pdo_stmt_t *stmt = Z_PDO_STMT_P(ZEND_THIS); \ if (!stmt->dbh) { \ - zend_throw_error(NULL, "%s object is uninitialized", ZSTR_VAL(Z_OBJ(EX(This))->ce->name)); \ + zend_throw_error(NULL, "%s object is uninitialized", ZSTR_VAL(Z_OBJ(EX(This))->ce->namespaced_name.name)); \ RETURN_THROWS(); \ } \ @@ -2162,7 +2162,7 @@ zend_object_iterator *pdo_stmt_iter_get(zend_class_entry *ce, zval *object, int pdo_stmt_t *stmt = Z_PDO_STMT_P(object); if (!stmt->dbh) { - zend_throw_error(NULL, "%s object is uninitialized", ZSTR_VAL(ce->name)); + zend_throw_error(NULL, "%s object is uninitialized", ZSTR_VAL(ce->namespaced_name.name)); return NULL; } diff --git a/ext/pdo/pdo_stmt_arginfo.h b/ext/pdo/pdo_stmt_arginfo.h index 0d4131d5be493..f86b9daa15c82 100644 --- a/ext/pdo/pdo_stmt_arginfo.h +++ b/ext/pdo/pdo_stmt_arginfo.h @@ -135,8 +135,10 @@ static const zend_function_entry class_PDOStatement_methods[] = { static zend_class_entry *register_class_PDOStatement(zend_class_entry *class_entry_IteratorAggregate) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "PDOStatement", class_PDOStatement_methods); + INIT_CLASS_NAME(namespaced_name, "PDOStatement"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_PDOStatement_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_IteratorAggregate); @@ -152,8 +154,10 @@ static zend_class_entry *register_class_PDOStatement(zend_class_entry *class_ent static zend_class_entry *register_class_PDORow(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "PDORow", NULL); + INIT_CLASS_NAME(namespaced_name, "PDORow"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NOT_SERIALIZABLE); zval property_queryString_default_value; diff --git a/ext/pdo/php_pdo.h b/ext/pdo/php_pdo.h index 1618c78d62284..65be71b308ee9 100644 --- a/ext/pdo/php_pdo.h +++ b/ext/pdo/php_pdo.h @@ -58,7 +58,7 @@ PHP_MINFO_FUNCTION(pdo); #define PDO_CONSTRUCT_CHECK_COND dbh->driver #define PDO_CONSTRUCT_CHECK_FAIL() \ { \ - zend_throw_error(NULL, "%s object is uninitialized", ZSTR_VAL(Z_OBJ(EX(This))->ce->name)); \ + zend_throw_error(NULL, "%s object is uninitialized", ZSTR_VAL(Z_OBJ(EX(This))->ce->namespaced_name.name)); \ } \ #define PDO_CONSTRUCT_CHECK \ diff --git a/ext/pdo_dblib/pdo_dblib_arginfo.h b/ext/pdo_dblib/pdo_dblib_arginfo.h index 1cf6c60d7a3b0..7a3eef79a2b1f 100644 --- a/ext/pdo_dblib/pdo_dblib_arginfo.h +++ b/ext/pdo_dblib/pdo_dblib_arginfo.h @@ -4,8 +4,10 @@ static zend_class_entry *register_class_Pdo_Dblib(zend_class_entry *class_entry_PDO) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Pdo", "Dblib", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Pdo", "Dblib"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_PDO, ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zval const_ATTR_CONNECTION_TIMEOUT_value; diff --git a/ext/pdo_firebird/pdo_firebird_arginfo.h b/ext/pdo_firebird/pdo_firebird_arginfo.h index a5a9c562c9c12..05fe748a0454e 100644 --- a/ext/pdo_firebird/pdo_firebird_arginfo.h +++ b/ext/pdo_firebird/pdo_firebird_arginfo.h @@ -14,8 +14,10 @@ static const zend_function_entry class_Pdo_Firebird_methods[] = { static zend_class_entry *register_class_Pdo_Firebird(zend_class_entry *class_entry_PDO) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Pdo", "Firebird", class_Pdo_Firebird_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Pdo", "Firebird"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Pdo_Firebird_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_PDO, ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zval const_ATTR_DATE_FORMAT_value; diff --git a/ext/pdo_mysql/pdo_mysql_arginfo.h b/ext/pdo_mysql/pdo_mysql_arginfo.h index a6a1b5e1b5c78..689bae598bbe7 100644 --- a/ext/pdo_mysql/pdo_mysql_arginfo.h +++ b/ext/pdo_mysql/pdo_mysql_arginfo.h @@ -14,8 +14,10 @@ static const zend_function_entry class_Pdo_Mysql_methods[] = { static zend_class_entry *register_class_Pdo_Mysql(zend_class_entry *class_entry_PDO) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Pdo", "Mysql", class_Pdo_Mysql_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Pdo", "Mysql"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Pdo_Mysql_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_PDO, ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zval const_ATTR_USE_BUFFERED_QUERY_value; diff --git a/ext/pdo_odbc/pdo_odbc_arginfo.h b/ext/pdo_odbc/pdo_odbc_arginfo.h index 5b1933d7594a0..1724deb240415 100644 --- a/ext/pdo_odbc/pdo_odbc_arginfo.h +++ b/ext/pdo_odbc/pdo_odbc_arginfo.h @@ -9,8 +9,10 @@ static void register_pdo_odbc_symbols(int module_number) static zend_class_entry *register_class_Pdo_Odbc(zend_class_entry *class_entry_PDO) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Pdo", "Odbc", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Pdo", "Odbc"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_PDO, ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zval const_ATTR_USE_CURSOR_LIBRARY_value; diff --git a/ext/pdo_pgsql/pdo_pgsql_arginfo.h b/ext/pdo_pgsql/pdo_pgsql_arginfo.h index f7f54cb600c72..5859fad226118 100644 --- a/ext/pdo_pgsql/pdo_pgsql_arginfo.h +++ b/ext/pdo_pgsql/pdo_pgsql_arginfo.h @@ -84,8 +84,10 @@ static const zend_function_entry class_Pdo_Pgsql_methods[] = { static zend_class_entry *register_class_Pdo_Pgsql(zend_class_entry *class_entry_PDO) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Pdo", "Pgsql", class_Pdo_Pgsql_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Pdo", "Pgsql"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Pdo_Pgsql_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_PDO, ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zval const_ATTR_DISABLE_PREPARES_value; diff --git a/ext/pdo_sqlite/pdo_sqlite_arginfo.h b/ext/pdo_sqlite/pdo_sqlite_arginfo.h index 4abbc0bb625c6..f9a78be90366a 100644 --- a/ext/pdo_sqlite/pdo_sqlite_arginfo.h +++ b/ext/pdo_sqlite/pdo_sqlite_arginfo.h @@ -56,8 +56,10 @@ static const zend_function_entry class_Pdo_Sqlite_methods[] = { static zend_class_entry *register_class_Pdo_Sqlite(zend_class_entry *class_entry_PDO) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Pdo", "Sqlite", class_Pdo_Sqlite_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Pdo", "Sqlite"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Pdo_Sqlite_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_PDO, ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); #if defined(SQLITE_DETERMINISTIC) diff --git a/ext/pgsql/pgsql_arginfo.h b/ext/pgsql/pgsql_arginfo.h index cb79f83971301..b0ee3ab13f7a8 100644 --- a/ext/pgsql/pgsql_arginfo.h +++ b/ext/pgsql/pgsql_arginfo.h @@ -1146,8 +1146,10 @@ static void register_pgsql_symbols(int module_number) static zend_class_entry *register_class_PgSql_Connection(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "PgSql", "Connection", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "PgSql", "Connection"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -1156,8 +1158,10 @@ static zend_class_entry *register_class_PgSql_Connection(void) static zend_class_entry *register_class_PgSql_Result(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "PgSql", "Result", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "PgSql", "Result"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -1166,8 +1170,10 @@ static zend_class_entry *register_class_PgSql_Result(void) static zend_class_entry *register_class_PgSql_Lob(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "PgSql", "Lob", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "PgSql", "Lob"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/phar/phar_object.c b/ext/phar/phar_object.c index 723339a431ee2..7963d9aeec9a7 100644 --- a/ext/phar/phar_object.c +++ b/ext/phar/phar_object.c @@ -1416,7 +1416,7 @@ static int phar_build(zend_object_iterator *iter, void *puser) /* {{{ */ if (!value) { /* failure in get_current_data */ - zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned no value", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned no value", ZSTR_VAL(ce->namespaced_name.name)); return ZEND_HASH_APPLY_STOP; } @@ -1427,7 +1427,7 @@ static int phar_build(zend_object_iterator *iter, void *puser) /* {{{ */ php_stream_from_zval_no_verify(fp, value); if (!fp) { - zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Iterator %s returned an invalid stream handle", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Iterator %s returned an invalid stream handle", ZSTR_VAL(ce->namespaced_name.name)); return ZEND_HASH_APPLY_STOP; } @@ -1441,7 +1441,7 @@ static int phar_build(zend_object_iterator *iter, void *puser) /* {{{ */ if (Z_TYPE(key) != IS_STRING) { zval_ptr_dtor(&key); - zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned an invalid key (must return a string)", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned an invalid key (must return a string)", ZSTR_VAL(ce->namespaced_name.name)); return ZEND_HASH_APPLY_STOP; } @@ -1451,7 +1451,7 @@ static int phar_build(zend_object_iterator *iter, void *puser) /* {{{ */ save = str_key; zval_ptr_dtor_str(&key); } else { - zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned an invalid key (must return a string)", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned an invalid key (must return a string)", ZSTR_VAL(ce->namespaced_name.name)); return ZEND_HASH_APPLY_STOP; } @@ -1464,7 +1464,7 @@ static int phar_build(zend_object_iterator *iter, void *puser) /* {{{ */ spl_filesystem_object *intern = (spl_filesystem_object*)((char*)Z_OBJ_P(value) - Z_OBJ_P(value)->handlers->offset); if (!base_len) { - zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Iterator %s returns an SplFileInfo object, so base directory must be specified", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Iterator %s returns an SplFileInfo object, so base directory must be specified", ZSTR_VAL(ce->namespaced_name.name)); return ZEND_HASH_APPLY_STOP; } @@ -1508,7 +1508,7 @@ static int phar_build(zend_object_iterator *iter, void *puser) /* {{{ */ } ZEND_FALLTHROUGH; default: - zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned an invalid value (must return a string, a stream, or an SplFileInfo object)", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned an invalid value (must return a string, a stream, or an SplFileInfo object)", ZSTR_VAL(ce->namespaced_name.name)); return ZEND_HASH_APPLY_STOP; } @@ -1548,7 +1548,7 @@ static int phar_build(zend_object_iterator *iter, void *puser) /* {{{ */ } } else { - zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned a path \"%s\" that is not in the base directory \"%s\"", ZSTR_VAL(ce->name), fname, base); + zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned a path \"%s\" that is not in the base directory \"%s\"", ZSTR_VAL(ce->namespaced_name.name), fname, base); if (save) { efree(save); @@ -1568,7 +1568,7 @@ static int phar_build(zend_object_iterator *iter, void *puser) /* {{{ */ if (Z_TYPE(key) != IS_STRING) { zval_ptr_dtor(&key); - zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned an invalid key (must return a string)", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned an invalid key (must return a string)", ZSTR_VAL(ce->namespaced_name.name)); return ZEND_HASH_APPLY_STOP; } @@ -1578,13 +1578,13 @@ static int phar_build(zend_object_iterator *iter, void *puser) /* {{{ */ save = str_key; zval_ptr_dtor_str(&key); } else { - zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned an invalid key (must return a string)", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned an invalid key (must return a string)", ZSTR_VAL(ce->namespaced_name.name)); return ZEND_HASH_APPLY_STOP; } } if (php_check_open_basedir(fname)) { - zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned a path \"%s\" that open_basedir prevents opening", ZSTR_VAL(ce->name), fname); + zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned a path \"%s\" that open_basedir prevents opening", ZSTR_VAL(ce->namespaced_name.name), fname); if (save) { efree(save); @@ -1601,7 +1601,7 @@ static int phar_build(zend_object_iterator *iter, void *puser) /* {{{ */ fp = php_stream_open_wrapper(fname, "rb", STREAM_MUST_SEEK|0, &opened); if (!fp) { - zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned a file that could not be opened \"%s\"", ZSTR_VAL(ce->name), fname); + zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0, "Iterator %s returned a file that could not be opened \"%s\"", ZSTR_VAL(ce->namespaced_name.name), fname); if (save) { efree(save); diff --git a/ext/phar/phar_object_arginfo.h b/ext/phar/phar_object_arginfo.h index e6c5ac75e9e7a..4376ca25fa24d 100644 --- a/ext/phar/phar_object_arginfo.h +++ b/ext/phar/phar_object_arginfo.h @@ -607,8 +607,10 @@ static const zend_function_entry class_PharFileInfo_methods[] = { static zend_class_entry *register_class_PharException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "PharException", NULL); + INIT_CLASS_NAME(namespaced_name, "PharException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, 0); return class_entry; @@ -617,8 +619,10 @@ static zend_class_entry *register_class_PharException(zend_class_entry *class_en static zend_class_entry *register_class_Phar(zend_class_entry *class_entry_RecursiveDirectoryIterator, zend_class_entry *class_entry_Countable, zend_class_entry *class_entry_ArrayAccess) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Phar", class_Phar_methods); + INIT_CLASS_NAME(namespaced_name, "Phar"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Phar_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RecursiveDirectoryIterator, 0); zend_class_implements(class_entry, 2, class_entry_Countable, class_entry_ArrayAccess); @@ -724,8 +728,10 @@ static zend_class_entry *register_class_Phar(zend_class_entry *class_entry_Recur static zend_class_entry *register_class_PharData(zend_class_entry *class_entry_RecursiveDirectoryIterator, zend_class_entry *class_entry_Countable, zend_class_entry *class_entry_ArrayAccess) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "PharData", class_PharData_methods); + INIT_CLASS_NAME(namespaced_name, "PharData"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_PharData_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RecursiveDirectoryIterator, 0); zend_class_implements(class_entry, 2, class_entry_Countable, class_entry_ArrayAccess); @@ -735,8 +741,10 @@ static zend_class_entry *register_class_PharData(zend_class_entry *class_entry_R static zend_class_entry *register_class_PharFileInfo(zend_class_entry *class_entry_SplFileInfo) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "PharFileInfo", class_PharFileInfo_methods); + INIT_CLASS_NAME(namespaced_name, "PharFileInfo"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_PharFileInfo_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_SplFileInfo, 0); return class_entry; diff --git a/ext/random/engine_mt19937.c b/ext/random/engine_mt19937.c index 7c9d1741d81f1..6300a67b63d3b 100644 --- a/ext/random/engine_mt19937.c +++ b/ext/random/engine_mt19937.c @@ -351,30 +351,30 @@ PHP_METHOD(Random_Engine_Mt19937, __unserialize) /* Verify the expected number of elements, this implicitly ensures that no additional elements are present. */ if (zend_hash_num_elements(d) != 2) { - zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->name)); + zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->namespaced_name.name)); RETURN_THROWS(); } /* members */ t = zend_hash_index_find(d, 0); if (!t || Z_TYPE_P(t) != IS_ARRAY) { - zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->name)); + zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->namespaced_name.name)); RETURN_THROWS(); } object_properties_load(&engine->std, Z_ARRVAL_P(t)); if (EG(exception)) { - zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->name)); + zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->namespaced_name.name)); RETURN_THROWS(); } /* state */ t = zend_hash_index_find(d, 1); if (!t || Z_TYPE_P(t) != IS_ARRAY) { - zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->name)); + zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->namespaced_name.name)); RETURN_THROWS(); } if (!engine->engine.algo->unserialize(engine->engine.state, Z_ARRVAL_P(t))) { - zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->name)); + zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->namespaced_name.name)); RETURN_THROWS(); } } diff --git a/ext/random/random_arginfo.h b/ext/random/random_arginfo.h index 3b06d7ba9e4f3..e4c61e8e7ac43 100644 --- a/ext/random/random_arginfo.h +++ b/ext/random/random_arginfo.h @@ -245,8 +245,10 @@ static void register_random_symbols(int module_number) static zend_class_entry *register_class_Random_Engine_Mt19937(zend_class_entry *class_entry_Random_Engine) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Random\\Engine", "Mt19937", class_Random_Engine_Mt19937_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Random\\Engine", "Mt19937"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Random_Engine_Mt19937_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES); zend_class_implements(class_entry, 1, class_entry_Random_Engine); @@ -256,8 +258,10 @@ static zend_class_entry *register_class_Random_Engine_Mt19937(zend_class_entry * static zend_class_entry *register_class_Random_Engine_PcgOneseq128XslRr64(zend_class_entry *class_entry_Random_Engine) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Random\\Engine", "PcgOneseq128XslRr64", class_Random_Engine_PcgOneseq128XslRr64_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Random\\Engine", "PcgOneseq128XslRr64"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Random_Engine_PcgOneseq128XslRr64_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES); zend_class_implements(class_entry, 1, class_entry_Random_Engine); @@ -267,8 +271,10 @@ static zend_class_entry *register_class_Random_Engine_PcgOneseq128XslRr64(zend_c static zend_class_entry *register_class_Random_Engine_Xoshiro256StarStar(zend_class_entry *class_entry_Random_Engine) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Random\\Engine", "Xoshiro256StarStar", class_Random_Engine_Xoshiro256StarStar_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Random\\Engine", "Xoshiro256StarStar"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Random_Engine_Xoshiro256StarStar_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES); zend_class_implements(class_entry, 1, class_entry_Random_Engine); @@ -278,8 +284,10 @@ static zend_class_entry *register_class_Random_Engine_Xoshiro256StarStar(zend_cl static zend_class_entry *register_class_Random_Engine_Secure(zend_class_entry *class_entry_Random_CryptoSafeEngine) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Random\\Engine", "Secure", class_Random_Engine_Secure_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Random\\Engine", "Secure"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Random_Engine_Secure_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Random_CryptoSafeEngine); @@ -289,8 +297,10 @@ static zend_class_entry *register_class_Random_Engine_Secure(zend_class_entry *c static zend_class_entry *register_class_Random_Engine(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Random", "Engine", class_Random_Engine_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Random", "Engine"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Random_Engine_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -299,8 +309,10 @@ static zend_class_entry *register_class_Random_Engine(void) static zend_class_entry *register_class_Random_CryptoSafeEngine(zend_class_entry *class_entry_Random_Engine) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Random", "CryptoSafeEngine", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Random", "CryptoSafeEngine"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_interface(&ce); zend_class_implements(class_entry, 1, class_entry_Random_Engine); @@ -310,8 +322,10 @@ static zend_class_entry *register_class_Random_CryptoSafeEngine(zend_class_entry static zend_class_entry *register_class_Random_Randomizer(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Random", "Randomizer", class_Random_Randomizer_methods); + INIT_CLASS_NAME_NS(namespaced_name, "Random", "Randomizer"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Random_Randomizer_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES); zval property_engine_default_value; @@ -342,8 +356,10 @@ static zend_class_entry *register_class_Random_IntervalBoundary(void) static zend_class_entry *register_class_Random_RandomError(zend_class_entry *class_entry_Error) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Random", "RandomError", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Random", "RandomError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Error, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; @@ -352,8 +368,10 @@ static zend_class_entry *register_class_Random_RandomError(zend_class_entry *cla static zend_class_entry *register_class_Random_BrokenRandomEngineError(zend_class_entry *class_entry_Random_RandomError) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Random", "BrokenRandomEngineError", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Random", "BrokenRandomEngineError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Random_RandomError, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; @@ -362,8 +380,10 @@ static zend_class_entry *register_class_Random_BrokenRandomEngineError(zend_clas static zend_class_entry *register_class_Random_RandomException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Random", "RandomException", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Random", "RandomException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; diff --git a/ext/readline/readline_cli.c b/ext/readline/readline_cli.c index 312129991c708..52f6430ae1483 100644 --- a/ext/readline/readline_cli.c +++ b/ext/readline/readline_cli.c @@ -487,7 +487,7 @@ static char *cli_completion_generator_class(const char *text, size_t textlen, in char *retval = cli_completion_generator_ht(text, textlen, state, EG(class_table), (void**)&ce); if (retval) { rl_completion_append_character = '\0'; - retval = strdup(ZSTR_VAL(ce->name)); + retval = strdup(ZSTR_VAL(ce->namespaced_name.name)); } return retval; @@ -575,10 +575,10 @@ static char *cli_completion_generator(const char *text, int index) /* {{{ */ zend_string_release_ex(class_name, 0); } if (ce && retval) { - size_t len = ZSTR_LEN(ce->name) + 2 + strlen(retval) + 1; + size_t len = ZSTR_LEN(ce->namespaced_name.name) + 2 + strlen(retval) + 1; char *tmp = malloc(len); - snprintf(tmp, len, "%s::%s", ZSTR_VAL(ce->name), retval); + snprintf(tmp, len, "%s::%s", ZSTR_VAL(ce->namespaced_name.name), retval); free(retval); retval = tmp; } diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index bc8ffbdd8bd8e..ce99495b43ddc 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -357,9 +357,9 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, const } smart_str_append_printf(str, "class "); } - smart_str_append_printf(str, "%s", ZSTR_VAL(ce->name)); + smart_str_append_printf(str, "%s", ZSTR_VAL(ce->namespaced_name.name)); if (ce->parent) { - smart_str_append_printf(str, " extends %s", ZSTR_VAL(ce->parent->name)); + smart_str_append_printf(str, " extends %s", ZSTR_VAL(ce->parent->namespaced_name.name)); } if (ce->num_interfaces) { @@ -367,12 +367,12 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, const ZEND_ASSERT(ce->ce_flags & ZEND_ACC_LINKED); if (ce->ce_flags & ZEND_ACC_INTERFACE) { - smart_str_append_printf(str, " extends %s", ZSTR_VAL(ce->interfaces[0]->name)); + smart_str_append_printf(str, " extends %s", ZSTR_VAL(ce->interfaces[0]->namespaced_name.name)); } else { - smart_str_append_printf(str, " implements %s", ZSTR_VAL(ce->interfaces[0]->name)); + smart_str_append_printf(str, " implements %s", ZSTR_VAL(ce->interfaces[0]->namespaced_name.name)); } for (i = 1; i < ce->num_interfaces; ++i) { - smart_str_append_printf(str, ", %s", ZSTR_VAL(ce->interfaces[i]->name)); + smart_str_append_printf(str, ", %s", ZSTR_VAL(ce->interfaces[i]->namespaced_name.name)); } } smart_str_append_printf(str, " ] {\n"); @@ -690,7 +690,7 @@ static int format_default_value(smart_str *str, zval *value) { zend_class_entry *class = obj->ce; ZEND_ASSERT(!(class->ce_flags & ZEND_ACC_ENUM)); smart_str_appends(str, "object("); - smart_str_append(str, class->name); + smart_str_append(str, class->namespaced_name.name); smart_str_appends(str, ")"); } else { ZEND_ASSERT(Z_TYPE_P(value) == IS_CONSTANT_AST); @@ -838,19 +838,19 @@ static void _function_string(smart_str *str, zend_function *fptr, zend_class_ent if (scope && fptr->common.scope) { if (fptr->common.scope != scope) { - smart_str_append_printf(str, ", inherits %s", ZSTR_VAL(fptr->common.scope->name)); + smart_str_append_printf(str, ", inherits %s", ZSTR_VAL(fptr->common.scope->namespaced_name.name)); } else if (fptr->common.scope->parent) { lc_name = zend_string_tolower(fptr->common.function_name); if ((overwrites = zend_hash_find_ptr(&fptr->common.scope->parent->function_table, lc_name)) != NULL) { if (fptr->common.scope != overwrites->common.scope && !(overwrites->common.fn_flags & ZEND_ACC_PRIVATE)) { - smart_str_append_printf(str, ", overwrites %s", ZSTR_VAL(overwrites->common.scope->name)); + smart_str_append_printf(str, ", overwrites %s", ZSTR_VAL(overwrites->common.scope->namespaced_name.name)); } } zend_string_release_ex(lc_name, 0); } } if (fptr->common.prototype && fptr->common.prototype->common.scope) { - smart_str_append_printf(str, ", prototype %s", ZSTR_VAL(fptr->common.prototype->common.scope->name)); + smart_str_append_printf(str, ", prototype %s", ZSTR_VAL(fptr->common.prototype->common.scope->namespaced_name.name)); } if (fptr->common.fn_flags & ZEND_ACC_CTOR) { smart_str_appends(str, ", ctor"); @@ -1038,7 +1038,7 @@ static void _extension_class_string(zend_class_entry *ce, zend_string *key, smar { if (ce->type == ZEND_INTERNAL_CLASS && ce->info.internal.module && !strcasecmp(ce->info.internal.module->name, module->name)) { /* dump class if it is not an alias */ - if (zend_string_equals_ci(ce->name, key)) { + if (zend_string_equals_ci(ce->namespaced_name.name, key)) { smart_str_append_printf(str, "\n"); _class_string(str, ce, NULL, indent); (*num_classes)++; @@ -1331,7 +1331,7 @@ PHPAPI void zend_reflection_class_factory(zend_class_entry *ce, zval *object) intern->ptr = ce; intern->ref_type = REF_TYPE_OTHER; intern->ce = ce; - ZVAL_STR_COPY(reflection_prop_name(object), ce->name); + ZVAL_STR_COPY(reflection_prop_name(object), ce->namespaced_name.name); } /* }}} */ @@ -1508,7 +1508,7 @@ static void reflection_method_factory(zend_class_entry *ce, zend_function *metho } ZVAL_STR_COPY(reflection_prop_name(object), method->common.function_name); - ZVAL_STR_COPY(reflection_prop_class(object), method->common.scope->name); + ZVAL_STR_COPY(reflection_prop_class(object), method->common.scope->namespaced_name.name); } /* }}} */ @@ -1528,7 +1528,7 @@ static void reflection_property_factory(zend_class_entry *ce, zend_string *name, intern->ref_type = REF_TYPE_PROPERTY; intern->ce = ce; ZVAL_STR_COPY(reflection_prop_name(object), name); - ZVAL_STR_COPY(reflection_prop_class(object), prop ? prop->ce->name : ce->name); + ZVAL_STR_COPY(reflection_prop_class(object), prop ? prop->ce->namespaced_name.name : ce->namespaced_name.name); } /* }}} */ @@ -1551,7 +1551,7 @@ static void reflection_class_constant_factory(zend_string *name_str, zend_class_ intern->ce = constant->ce; ZVAL_STR_COPY(reflection_prop_name(object), name_str); - ZVAL_STR_COPY(reflection_prop_class(object), constant->ce->name); + ZVAL_STR_COPY(reflection_prop_class(object), constant->ce->namespaced_name.name); } /* }}} */ @@ -1569,7 +1569,7 @@ static void reflection_enum_case_factory(zend_class_entry *ce, zend_string *name intern->ce = constant->ce; ZVAL_STR_COPY(reflection_prop_name(object), name_str); - ZVAL_STR_COPY(reflection_prop_class(object), constant->ce->name); + ZVAL_STR_COPY(reflection_prop_class(object), constant->ce->namespaced_name.name); } static int get_parameter_default(zval *result, parameter_reference *param) { @@ -2478,7 +2478,7 @@ ZEND_METHOD(ReflectionParameter, __construct) not the closure itself */ } else if ((fptr = zend_hash_find_ptr(&ce->function_table, lcname)) == NULL) { zend_throw_exception_ex(reflection_exception_ptr, 0, - "Method %s::%s() does not exist", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + "Method %s::%s() does not exist", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); zend_string_release(name); zend_string_release(lcname); RETURN_THROWS(); @@ -2497,7 +2497,7 @@ ZEND_METHOD(ReflectionParameter, __construct) is_closure = 1; } else if ((fptr = zend_hash_find_ptr(&ce->function_table, ZSTR_KNOWN(ZEND_STR_MAGIC_INVOKE))) == NULL) { zend_throw_exception_ex(reflection_exception_ptr, 0, - "Method %s::%s() does not exist", ZSTR_VAL(ce->name), ZEND_INVOKE_FUNC_NAME); + "Method %s::%s() does not exist", ZSTR_VAL(ce->namespaced_name.name), ZEND_INVOKE_FUNC_NAME); RETURN_THROWS(); } } @@ -3270,13 +3270,13 @@ static void instantiate_reflection_method(INTERNAL_FUNCTION_PARAMETERS, bool is_ } else if ((mptr = zend_hash_str_find_ptr(&ce->function_table, lcname, method_name_len)) == NULL) { efree(lcname); zend_throw_exception_ex(reflection_exception_ptr, 0, - "Method %s::%s() does not exist", ZSTR_VAL(ce->name), method_name); + "Method %s::%s() does not exist", ZSTR_VAL(ce->namespaced_name.name), method_name); RETURN_THROWS(); } efree(lcname); ZVAL_STR_COPY(reflection_prop_name(object), mptr->common.function_name); - ZVAL_STR_COPY(reflection_prop_class(object), mptr->common.scope->name); + ZVAL_STR_COPY(reflection_prop_class(object), mptr->common.scope->namespaced_name.name); intern->ptr = mptr; intern->ref_type = REF_TYPE_FUNCTION; intern->ce = ce; @@ -3360,7 +3360,7 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) if (mptr->common.fn_flags & ZEND_ACC_ABSTRACT) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Trying to invoke abstract method %s::%s()", - ZSTR_VAL(mptr->common.scope->name), ZSTR_VAL(mptr->common.function_name)); + ZSTR_VAL(mptr->common.scope->namespaced_name.name), ZSTR_VAL(mptr->common.function_name)); RETURN_THROWS(); } @@ -3388,7 +3388,7 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) if (!object) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Trying to invoke non static method %s::%s() without an object", - ZSTR_VAL(mptr->common.scope->name), ZSTR_VAL(mptr->common.function_name)); + ZSTR_VAL(mptr->common.scope->namespaced_name.name), ZSTR_VAL(mptr->common.function_name)); RETURN_THROWS(); } @@ -3408,7 +3408,7 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) if (Z_TYPE(retval) == IS_UNDEF && !EG(exception)) { zend_throw_exception_ex(reflection_exception_ptr, 0, - "Invocation of method %s::%s() failed", ZSTR_VAL(mptr->common.scope->name), ZSTR_VAL(mptr->common.function_name)); + "Invocation of method %s::%s() failed", ZSTR_VAL(mptr->common.scope->namespaced_name.name), ZSTR_VAL(mptr->common.function_name)); RETURN_THROWS(); } @@ -3707,7 +3707,7 @@ ZEND_METHOD(ReflectionMethod, getPrototype) if (!mptr->common.prototype) { zend_throw_exception_ex(reflection_exception_ptr, 0, - "Method %s::%s does not have a prototype", ZSTR_VAL(intern->ce->name), ZSTR_VAL(mptr->common.function_name)); + "Method %s::%s does not have a prototype", ZSTR_VAL(intern->ce->namespaced_name.name), ZSTR_VAL(mptr->common.function_name)); RETURN_THROWS(); } @@ -3755,7 +3755,7 @@ ZEND_METHOD(ReflectionClassConstant, __construct) intern = Z_REFLECTION_P(object); if ((constant = zend_hash_find_ptr(CE_CONSTANTS_TABLE(ce), constname)) == NULL) { - zend_throw_exception_ex(reflection_exception_ptr, 0, "Constant %s::%s does not exist", ZSTR_VAL(ce->name), ZSTR_VAL(constname)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "Constant %s::%s does not exist", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(constname)); RETURN_THROWS(); } @@ -3763,7 +3763,7 @@ ZEND_METHOD(ReflectionClassConstant, __construct) intern->ref_type = REF_TYPE_CLASS_CONSTANT; intern->ce = constant->ce; ZVAL_STR_COPY(reflection_prop_name(object), constname); - ZVAL_STR_COPY(reflection_prop_class(object), constant->ce->name); + ZVAL_STR_COPY(reflection_prop_class(object), constant->ce->namespaced_name.name); } /* }}} */ @@ -4007,7 +4007,7 @@ static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_ob /* Note: class entry name is interned, no need to destroy them */ if (arg_obj) { - ZVAL_STR_COPY(reflection_prop_name(object), arg_obj->ce->name); + ZVAL_STR_COPY(reflection_prop_name(object), arg_obj->ce->namespaced_name.name); intern->ptr = arg_obj->ce; if (is_object) { zval_ptr_dtor(&intern->obj); @@ -4021,7 +4021,7 @@ static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_ob RETURN_THROWS(); } - ZVAL_STR_COPY(reflection_prop_name(object), ce->name); + ZVAL_STR_COPY(reflection_prop_name(object), ce->namespaced_name.name); intern->ptr = ce; } intern->ref_type = REF_TYPE_OTHER; @@ -4075,6 +4075,54 @@ static void add_class_vars(zend_class_entry *ce, bool statics, zval *return_valu } /* }}} */ +/* {{{ Returns whether the current class is an inner class */ +ZEND_METHOD(ReflectionClass, isInnerClass) +{ + reflection_object *intern; + zend_class_entry *ce; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(ce); + + + //inner classes have a lexical scope, normal classes do not + RETURN_BOOL(ce->lexical_scope != NULL); +} +/* }}} */ + +/* {{{ Returns true if the class is private */ +ZEND_METHOD(ReflectionClass, isPrivate) +{ + reflection_object *intern; + zend_class_entry *ce; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(ce); + RETURN_BOOL(ce->required_scope && ce->required_scope_absolute); +} + +/* {{{ Returns true if the class is protected */ +ZEND_METHOD(ReflectionClass, isProtected) +{ + reflection_object *intern; + zend_class_entry *ce; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(ce); + RETURN_BOOL(ce->required_scope && !ce->required_scope_absolute); +} + +/* {{{ Returns true if the class is public */ +ZEND_METHOD(ReflectionClass, isPublic) +{ + reflection_object *intern; + zend_class_entry *ce; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(ce); + RETURN_BOOL(!ce->required_scope); +} + /* {{{ Returns an associative array containing all static property values of the class */ ZEND_METHOD(ReflectionClass, getStaticProperties) { @@ -4156,10 +4204,10 @@ ZEND_METHOD(ReflectionClass, getStaticPropertyValue) if (prop) { zend_throw_error(NULL, - "Typed property %s::$%s must not be accessed before initialization", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + "Typed property %s::$%s must not be accessed before initialization", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } else { zend_throw_exception_ex(reflection_exception_ptr, 0, - "Property %s::$%s does not exist", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + "Property %s::$%s does not exist", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } } /* }}} */ @@ -4189,7 +4237,7 @@ ZEND_METHOD(ReflectionClass, setStaticPropertyValue) if (!variable_ptr) { zend_clear_exception(); zend_throw_exception_ex(reflection_exception_ptr, 0, - "Class %s does not have a property named %s", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + "Class %s does not have a property named %s", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); RETURN_THROWS(); } @@ -4252,7 +4300,7 @@ ZEND_METHOD(ReflectionClass, getName) ZEND_PARSE_PARAMETERS_NONE(); GET_REFLECTION_OBJECT_PTR(ce); - RETURN_STR_COPY(ce->name); + RETURN_STR_COPY(ce->namespaced_name.name); } /* }}} */ @@ -4432,7 +4480,7 @@ ZEND_METHOD(ReflectionClass, getMethod) reflection_method_factory(ce, mptr, NULL, return_value); } else { zend_throw_exception_ex(reflection_exception_ptr, 0, - "Method %s::%s() does not exist", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + "Method %s::%s() does not exist", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); } zend_string_release(lc_name); } @@ -4578,7 +4626,7 @@ ZEND_METHOD(ReflectionClass, getProperty) zend_string_release_ex(classname, 0); if (!instanceof_function(ce, ce2)) { - zend_throw_exception_ex(reflection_exception_ptr, -1, "Fully qualified property name %s::$%s does not specify a base class of %s", ZSTR_VAL(ce2->name), str_name, ZSTR_VAL(ce->name)); + zend_throw_exception_ex(reflection_exception_ptr, -1, "Fully qualified property name %s::$%s does not specify a base class of %s", ZSTR_VAL(ce2->namespaced_name.name), str_name, ZSTR_VAL(ce->namespaced_name.name)); RETURN_THROWS(); } ce = ce2; @@ -4591,7 +4639,7 @@ ZEND_METHOD(ReflectionClass, getProperty) return; } } - zend_throw_exception_ex(reflection_exception_ptr, 0, "Property %s::$%s does not exist", ZSTR_VAL(ce->name), str_name); + zend_throw_exception_ex(reflection_exception_ptr, 0, "Property %s::$%s does not exist", ZSTR_VAL(ce->namespaced_name.name), str_name); } /* }}} */ @@ -4956,7 +5004,7 @@ ZEND_METHOD(ReflectionClass, newInstance) HashTable *named_params; if (!(constructor->common.fn_flags & ZEND_ACC_PUBLIC)) { - zend_throw_exception_ex(reflection_exception_ptr, 0, "Access to non-public constructor of class %s", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "Access to non-public constructor of class %s", ZSTR_VAL(ce->namespaced_name.name)); zval_ptr_dtor(return_value); RETURN_NULL(); } @@ -4973,7 +5021,7 @@ ZEND_METHOD(ReflectionClass, newInstance) zend_object_store_ctor_failed(Z_OBJ_P(return_value)); } } else if (ZEND_NUM_ARGS()) { - zend_throw_exception_ex(reflection_exception_ptr, 0, "Class %s does not have a constructor, so you cannot pass any constructor arguments", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "Class %s does not have a constructor, so you cannot pass any constructor arguments", ZSTR_VAL(ce->namespaced_name.name)); } } /* }}} */ @@ -4990,7 +5038,7 @@ ZEND_METHOD(ReflectionClass, newInstanceWithoutConstructor) if (ce->type == ZEND_INTERNAL_CLASS && ce->create_object != NULL && (ce->ce_flags & ZEND_ACC_FINAL)) { - zend_throw_exception_ex(reflection_exception_ptr, 0, "Class %s is an internal class marked as final that cannot be instantiated without invoking its constructor", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "Class %s is an internal class marked as final that cannot be instantiated without invoking its constructor", ZSTR_VAL(ce->namespaced_name.name)); RETURN_THROWS(); } @@ -5029,7 +5077,7 @@ ZEND_METHOD(ReflectionClass, newInstanceArgs) /* Run the constructor if there is one */ if (constructor) { if (!(constructor->common.fn_flags & ZEND_ACC_PUBLIC)) { - zend_throw_exception_ex(reflection_exception_ptr, 0, "Access to non-public constructor of class %s", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "Access to non-public constructor of class %s", ZSTR_VAL(ce->namespaced_name.name)); zval_ptr_dtor(return_value); RETURN_NULL(); } @@ -5041,7 +5089,7 @@ ZEND_METHOD(ReflectionClass, newInstanceArgs) zend_object_store_ctor_failed(Z_OBJ_P(return_value)); } } else if (argc) { - zend_throw_exception_ex(reflection_exception_ptr, 0, "Class %s does not have a constructor, so you cannot pass any constructor arguments", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "Class %s does not have a constructor, so you cannot pass any constructor arguments", ZSTR_VAL(ce->namespaced_name.name)); } } /* }}} */ @@ -5258,7 +5306,7 @@ ZEND_METHOD(ReflectionClass, getInterfaces) for (i=0; i < ce->num_interfaces; i++) { zval interface; zend_reflection_class_factory(ce->interfaces[i], &interface); - zend_hash_update(Z_ARRVAL_P(return_value), ce->interfaces[i]->name, &interface); + zend_hash_update(Z_ARRVAL_P(return_value), ce->interfaces[i]->namespaced_name.name, &interface); } } else { RETURN_EMPTY_ARRAY(); @@ -5285,7 +5333,7 @@ ZEND_METHOD(ReflectionClass, getInterfaceNames) array_init(return_value); for (i=0; i < ce->num_interfaces; i++) { - add_next_index_str(return_value, zend_string_copy(ce->interfaces[i]->name)); + add_next_index_str(return_value, zend_string_copy(ce->interfaces[i]->namespaced_name.name)); } } /* }}} */ @@ -5311,7 +5359,7 @@ ZEND_METHOD(ReflectionClass, getTraits) zend_class_entry *trait_ce; trait_ce = zend_fetch_class_by_name(ce->trait_names[i].name, - ce->trait_names[i].lc_name, ZEND_FETCH_CLASS_TRAIT); + ce->trait_names[i].resolved_name, ZEND_FETCH_CLASS_TRAIT); ZEND_ASSERT(trait_ce); zend_reflection_class_factory(trait_ce, &trait); zend_hash_update(Z_ARRVAL_P(return_value), ce->trait_names[i].name, &trait); @@ -5368,10 +5416,10 @@ ZEND_METHOD(ReflectionClass, getTraitAliases) for (j = 0; j < ce->num_traits; j++) { zend_class_entry *trait = - zend_hash_find_ptr(CG(class_table), ce->trait_names[j].lc_name); + zend_hash_find_ptr(CG(class_table), ce->trait_names[j].resolved_name); ZEND_ASSERT(trait && "Trait must exist"); if (zend_hash_exists(&trait->function_table, lcname)) { - class_name = trait->name; + class_name = trait->namespaced_name.name; break; } } @@ -5469,7 +5517,7 @@ ZEND_METHOD(ReflectionClass, implementsInterface) } if (!(interface_ce->ce_flags & ZEND_ACC_INTERFACE)) { - zend_throw_exception_ex(reflection_exception_ptr, 0, "%s is not an interface", ZSTR_VAL(interface_ce->name)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "%s is not an interface", ZSTR_VAL(interface_ce->namespaced_name.name)); RETURN_THROWS(); } @@ -5542,7 +5590,7 @@ ZEND_METHOD(ReflectionClass, inNamespace) GET_REFLECTION_OBJECT_PTR(ce); - zend_string *name = ce->name; + zend_string *name = ce->namespaced_name.name; const char *backslash = zend_memrchr(ZSTR_VAL(name), '\\', ZSTR_LEN(name)); RETURN_BOOL(backslash); } @@ -5558,7 +5606,7 @@ ZEND_METHOD(ReflectionClass, getNamespaceName) GET_REFLECTION_OBJECT_PTR(ce); - zend_string *name = ce->name; + zend_string *name = ce->namespaced_name.name; const char *backslash = zend_memrchr(ZSTR_VAL(name), '\\', ZSTR_LEN(name)); if (backslash) { RETURN_STRINGL(ZSTR_VAL(name), backslash - ZSTR_VAL(name)); @@ -5577,7 +5625,7 @@ ZEND_METHOD(ReflectionClass, getShortName) GET_REFLECTION_OBJECT_PTR(ce); - zend_string *name = ce->name; + zend_string *name = ce->namespaced_name.name; const char *backslash = zend_memrchr(ZSTR_VAL(name), '\\', ZSTR_LEN(name)); if (backslash) { RETURN_STRINGL(backslash + 1, ZSTR_LEN(name) - (backslash - ZSTR_VAL(name) + 1)); @@ -5634,7 +5682,7 @@ ZEND_METHOD(ReflectionProperty, __construct) } } if (dynam_prop == 0) { - zend_throw_exception_ex(reflection_exception_ptr, 0, "Property %s::$%s does not exist", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "Property %s::$%s does not exist", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); RETURN_THROWS(); } } @@ -5644,9 +5692,9 @@ ZEND_METHOD(ReflectionProperty, __construct) ZVAL_STR_COPY(prop_name, name); /* Note: class name are always interned, no need to destroy them */ if (dynam_prop == 0) { - ZVAL_STR_COPY(reflection_prop_class(object), property_info->ce->name); + ZVAL_STR_COPY(reflection_prop_class(object), property_info->ce->namespaced_name.name); } else { - ZVAL_STR_COPY(reflection_prop_class(object), ce->name); + ZVAL_STR_COPY(reflection_prop_class(object), ce->namespaced_name.name); } if (intern->ptr) { @@ -6032,7 +6080,7 @@ static zend_result reflection_property_check_lazy_compatible( if (!prop) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Can not use %s on dynamic property %s::$%s", - method, ZSTR_VAL(intern->ce->name), + method, ZSTR_VAL(intern->ce->namespaced_name.name), ZSTR_VAL(unmangled_name)); return FAILURE; } @@ -6040,7 +6088,7 @@ static zend_result reflection_property_check_lazy_compatible( if (prop->flags & ZEND_ACC_STATIC) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Can not use %s on static property %s::$%s", - method, ZSTR_VAL(prop->ce->name), + method, ZSTR_VAL(prop->ce->namespaced_name.name), ZSTR_VAL(unmangled_name)); return FAILURE; } @@ -6048,7 +6096,7 @@ static zend_result reflection_property_check_lazy_compatible( if (prop->flags & ZEND_ACC_VIRTUAL) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Can not use %s on virtual property %s::$%s", - method, ZSTR_VAL(prop->ce->name), + method, ZSTR_VAL(prop->ce->namespaced_name.name), ZSTR_VAL(unmangled_name)); return FAILURE; } @@ -6057,7 +6105,7 @@ static zend_result reflection_property_check_lazy_compatible( if (!zend_class_can_be_lazy(object->ce)) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Can not use %s on internal class %s", - method, ZSTR_VAL(object->ce->name)); + method, ZSTR_VAL(object->ce->namespaced_name.name)); return FAILURE; } } @@ -6697,12 +6745,12 @@ static void add_extension_class(zend_class_entry *ce, zend_string *key, zval *cl if (ce->type == ZEND_INTERNAL_CLASS && ce->info.internal.module && !strcasecmp(ce->info.internal.module->name, module->name)) { zend_string *name; - if (!zend_string_equals_ci(ce->name, key)) { + if (!zend_string_equals_ci(ce->namespaced_name.name, key)) { /* This is a class alias, use alias name */ name = key; } else { /* Use class name */ - name = ce->name; + name = ce->namespaced_name.name; } if (add_reflection_class) { zval zclass; @@ -7262,7 +7310,7 @@ ZEND_METHOD(ReflectionEnum, __construct) GET_REFLECTION_OBJECT_PTR(ce); if (!(ce->ce_flags & ZEND_ACC_ENUM)) { - zend_throw_exception_ex(reflection_exception_ptr, -1, "Class \"%s\" is not an enum", ZSTR_VAL(ce->name)); + zend_throw_exception_ex(reflection_exception_ptr, -1, "Class \"%s\" is not an enum", ZSTR_VAL(ce->namespaced_name.name)); RETURN_THROWS(); } } @@ -7301,11 +7349,11 @@ ZEND_METHOD(ReflectionEnum, getCase) zend_class_constant *constant = zend_hash_find_ptr(CE_CONSTANTS_TABLE(ce), name); if (constant == NULL) { - zend_throw_exception_ex(reflection_exception_ptr, 0, "Case %s::%s does not exist", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "Case %s::%s does not exist", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); RETURN_THROWS(); } if (!(ZEND_CLASS_CONST_FLAGS(constant) & ZEND_CLASS_CONST_IS_CASE)) { - zend_throw_exception_ex(reflection_exception_ptr, 0, "%s::%s is not a case", ZSTR_VAL(ce->name), ZSTR_VAL(name)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "%s::%s is not a case", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(name)); RETURN_THROWS(); } @@ -7375,7 +7423,7 @@ ZEND_METHOD(ReflectionEnumUnitCase, __construct) if (!(ZEND_CLASS_CONST_FLAGS(ref) & ZEND_CLASS_CONST_IS_CASE)) { zval *case_name = reflection_prop_name(ZEND_THIS); - zend_throw_exception_ex(reflection_exception_ptr, 0, "Constant %s::%s is not a case", ZSTR_VAL(ref->ce->name), Z_STRVAL_P(case_name)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "Constant %s::%s is not a case", ZSTR_VAL(ref->ce->namespaced_name.name), Z_STRVAL_P(case_name)); RETURN_THROWS(); } } @@ -7405,7 +7453,7 @@ ZEND_METHOD(ReflectionEnumBackedCase, __construct) if (ref->ce->enum_backing_type == IS_UNDEF) { zval *case_name = reflection_prop_name(ZEND_THIS); - zend_throw_exception_ex(reflection_exception_ptr, 0, "Enum case %s::%s is not a backed case", ZSTR_VAL(ref->ce->name), Z_STRVAL_P(case_name)); + zend_throw_exception_ex(reflection_exception_ptr, 0, "Enum case %s::%s is not a backed case", ZSTR_VAL(ref->ce->namespaced_name.name), Z_STRVAL_P(case_name)); RETURN_THROWS(); } } @@ -7564,7 +7612,7 @@ static zval *_reflection_write_property(zend_object *object, zend_string *name, && (zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_NAME)) || zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_CLASS)))) { zend_throw_exception_ex(reflection_exception_ptr, 0, - "Cannot set read-only property %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(name)); + "Cannot set read-only property %s::$%s", ZSTR_VAL(object->ce->namespaced_name.name), ZSTR_VAL(name)); return &EG(uninitialized_zval); } else diff --git a/ext/reflection/php_reflection.stub.php b/ext/reflection/php_reflection.stub.php index be511d7ee14cd..6b03c6deb03c8 100644 --- a/ext/reflection/php_reflection.stub.php +++ b/ext/reflection/php_reflection.stub.php @@ -432,6 +432,14 @@ public function getNamespaceName(): string {} public function getShortName(): string {} public function getAttributes(?string $name = null, int $flags = 0): array {} + + public function isInnerClass(): bool {} + + public function isPrivate(): bool {} + + public function isProtected(): bool {} + + public function isPublic(): bool {} } class ReflectionObject extends ReflectionClass diff --git a/ext/reflection/php_reflection_arginfo.h b/ext/reflection/php_reflection_arginfo.h index d78a685dde9c9..08adebed54884 100644 --- a/ext/reflection/php_reflection_arginfo.h +++ b/ext/reflection/php_reflection_arginfo.h @@ -1,5 +1,5 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: 3c6be99bb36965139464925a618cb0bf03affa62 */ + * Stub hash: be0cae939aa05863ce2206767bbb923ea9951dd7 */ ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_Reflection_getModifierNames, 0, 1, IS_ARRAY, 0) ZEND_ARG_TYPE_INFO(0, modifiers, IS_LONG, 0) @@ -366,6 +366,14 @@ ZEND_END_ARG_INFO() #define arginfo_class_ReflectionClass_getAttributes arginfo_class_ReflectionFunctionAbstract_getAttributes +#define arginfo_class_ReflectionClass_isInnerClass arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType + +#define arginfo_class_ReflectionClass_isPrivate arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType + +#define arginfo_class_ReflectionClass_isProtected arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType + +#define arginfo_class_ReflectionClass_isPublic arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType + ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ReflectionObject___construct, 0, 0, 1) ZEND_ARG_TYPE_INFO(0, object, IS_OBJECT, 0) ZEND_END_ARG_INFO() @@ -847,6 +855,10 @@ ZEND_METHOD(ReflectionClass, inNamespace); ZEND_METHOD(ReflectionClass, getNamespaceName); ZEND_METHOD(ReflectionClass, getShortName); ZEND_METHOD(ReflectionClass, getAttributes); +ZEND_METHOD(ReflectionClass, isInnerClass); +ZEND_METHOD(ReflectionClass, isPrivate); +ZEND_METHOD(ReflectionClass, isProtected); +ZEND_METHOD(ReflectionClass, isPublic); ZEND_METHOD(ReflectionObject, __construct); ZEND_METHOD(ReflectionProperty, __construct); ZEND_METHOD(ReflectionProperty, __toString); @@ -1139,6 +1151,10 @@ static const zend_function_entry class_ReflectionClass_methods[] = { ZEND_ME(ReflectionClass, getNamespaceName, arginfo_class_ReflectionClass_getNamespaceName, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionClass, getShortName, arginfo_class_ReflectionClass_getShortName, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionClass, getAttributes, arginfo_class_ReflectionClass_getAttributes, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionClass, isInnerClass, arginfo_class_ReflectionClass_isInnerClass, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionClass, isPrivate, arginfo_class_ReflectionClass_isPrivate, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionClass, isProtected, arginfo_class_ReflectionClass_isProtected, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionClass, isPublic, arginfo_class_ReflectionClass_isPublic, ZEND_ACC_PUBLIC) ZEND_FE_END }; @@ -1361,8 +1377,10 @@ static const zend_function_entry class_ReflectionConstant_methods[] = { static zend_class_entry *register_class_ReflectionException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionException", NULL); + INIT_CLASS_NAME(namespaced_name, "ReflectionException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, 0); return class_entry; @@ -1371,8 +1389,10 @@ static zend_class_entry *register_class_ReflectionException(zend_class_entry *cl static zend_class_entry *register_class_Reflection(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Reflection", class_Reflection_methods); + INIT_CLASS_NAME(namespaced_name, "Reflection"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Reflection_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); return class_entry; @@ -1381,8 +1401,10 @@ static zend_class_entry *register_class_Reflection(void) static zend_class_entry *register_class_Reflector(zend_class_entry *class_entry_Stringable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Reflector", NULL); + INIT_CLASS_NAME(namespaced_name, "Reflector"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_interface(&ce); zend_class_implements(class_entry, 1, class_entry_Stringable); @@ -1392,8 +1414,10 @@ static zend_class_entry *register_class_Reflector(zend_class_entry *class_entry_ static zend_class_entry *register_class_ReflectionFunctionAbstract(zend_class_entry *class_entry_Reflector) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionFunctionAbstract", class_ReflectionFunctionAbstract_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionFunctionAbstract"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionFunctionAbstract_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_ABSTRACT|ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Reflector); @@ -1407,8 +1431,10 @@ static zend_class_entry *register_class_ReflectionFunctionAbstract(zend_class_en static zend_class_entry *register_class_ReflectionFunction(zend_class_entry *class_entry_ReflectionFunctionAbstract) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionFunction", class_ReflectionFunction_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionFunction"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionFunction_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ReflectionFunctionAbstract, 0); zval const_IS_DEPRECATED_value; @@ -1436,8 +1462,10 @@ static zend_class_entry *register_class_ReflectionFunction(zend_class_entry *cla static zend_class_entry *register_class_ReflectionGenerator(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionGenerator", class_ReflectionGenerator_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionGenerator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionGenerator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -1446,8 +1474,10 @@ static zend_class_entry *register_class_ReflectionGenerator(void) static zend_class_entry *register_class_ReflectionMethod(zend_class_entry *class_entry_ReflectionFunctionAbstract) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionMethod", class_ReflectionMethod_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionMethod"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionMethod_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ReflectionFunctionAbstract, 0); zval const_IS_STATIC_value; @@ -1496,8 +1526,10 @@ static zend_class_entry *register_class_ReflectionMethod(zend_class_entry *class static zend_class_entry *register_class_ReflectionClass(zend_class_entry *class_entry_Reflector) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionClass", class_ReflectionClass_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionClass"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionClass_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Reflector); @@ -1547,8 +1579,10 @@ static zend_class_entry *register_class_ReflectionClass(zend_class_entry *class_ static zend_class_entry *register_class_ReflectionObject(zend_class_entry *class_entry_ReflectionClass) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionObject", class_ReflectionObject_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionObject"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionObject_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ReflectionClass, 0); return class_entry; @@ -1574,8 +1608,10 @@ static zend_class_entry *register_class_PropertyHookType(void) static zend_class_entry *register_class_ReflectionProperty(zend_class_entry *class_entry_Reflector) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionProperty", class_ReflectionProperty_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionProperty"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionProperty_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Reflector); @@ -1653,8 +1689,10 @@ static zend_class_entry *register_class_ReflectionProperty(zend_class_entry *cla static zend_class_entry *register_class_ReflectionClassConstant(zend_class_entry *class_entry_Reflector) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionClassConstant", class_ReflectionClassConstant_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionClassConstant"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionClassConstant_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Reflector); @@ -1696,8 +1734,10 @@ static zend_class_entry *register_class_ReflectionClassConstant(zend_class_entry static zend_class_entry *register_class_ReflectionParameter(zend_class_entry *class_entry_Reflector) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionParameter", class_ReflectionParameter_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionParameter"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionParameter_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Reflector); @@ -1748,8 +1788,10 @@ static zend_class_entry *register_class_ReflectionParameter(zend_class_entry *cl static zend_class_entry *register_class_ReflectionType(zend_class_entry *class_entry_Stringable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionType", class_ReflectionType_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionType"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionType_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_ABSTRACT|ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Stringable); @@ -1759,8 +1801,10 @@ static zend_class_entry *register_class_ReflectionType(zend_class_entry *class_e static zend_class_entry *register_class_ReflectionNamedType(zend_class_entry *class_entry_ReflectionType) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionNamedType", class_ReflectionNamedType_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionNamedType"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionNamedType_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ReflectionType, 0); return class_entry; @@ -1769,8 +1813,10 @@ static zend_class_entry *register_class_ReflectionNamedType(zend_class_entry *cl static zend_class_entry *register_class_ReflectionUnionType(zend_class_entry *class_entry_ReflectionType) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionUnionType", class_ReflectionUnionType_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionUnionType"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionUnionType_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ReflectionType, 0); return class_entry; @@ -1779,8 +1825,10 @@ static zend_class_entry *register_class_ReflectionUnionType(zend_class_entry *cl static zend_class_entry *register_class_ReflectionIntersectionType(zend_class_entry *class_entry_ReflectionType) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionIntersectionType", class_ReflectionIntersectionType_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionIntersectionType"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionIntersectionType_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ReflectionType, 0); return class_entry; @@ -1789,8 +1837,10 @@ static zend_class_entry *register_class_ReflectionIntersectionType(zend_class_en static zend_class_entry *register_class_ReflectionExtension(zend_class_entry *class_entry_Reflector) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionExtension", class_ReflectionExtension_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionExtension"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionExtension_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Reflector); @@ -1804,8 +1854,10 @@ static zend_class_entry *register_class_ReflectionExtension(zend_class_entry *cl static zend_class_entry *register_class_ReflectionZendExtension(zend_class_entry *class_entry_Reflector) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionZendExtension", class_ReflectionZendExtension_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionZendExtension"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionZendExtension_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Reflector); @@ -1819,8 +1871,10 @@ static zend_class_entry *register_class_ReflectionZendExtension(zend_class_entry static zend_class_entry *register_class_ReflectionReference(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionReference", class_ReflectionReference_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionReference"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionReference_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -1829,8 +1883,10 @@ static zend_class_entry *register_class_ReflectionReference(void) static zend_class_entry *register_class_ReflectionAttribute(zend_class_entry *class_entry_Reflector) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionAttribute", class_ReflectionAttribute_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionAttribute"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionAttribute_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Reflector); @@ -1850,8 +1906,10 @@ static zend_class_entry *register_class_ReflectionAttribute(zend_class_entry *cl static zend_class_entry *register_class_ReflectionEnum(zend_class_entry *class_entry_ReflectionClass) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionEnum", class_ReflectionEnum_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionEnum"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionEnum_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ReflectionClass, 0); return class_entry; @@ -1860,8 +1918,10 @@ static zend_class_entry *register_class_ReflectionEnum(zend_class_entry *class_e static zend_class_entry *register_class_ReflectionEnumUnitCase(zend_class_entry *class_entry_ReflectionClassConstant) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionEnumUnitCase", class_ReflectionEnumUnitCase_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionEnumUnitCase"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionEnumUnitCase_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ReflectionClassConstant, 0); return class_entry; @@ -1870,8 +1930,10 @@ static zend_class_entry *register_class_ReflectionEnumUnitCase(zend_class_entry static zend_class_entry *register_class_ReflectionEnumBackedCase(zend_class_entry *class_entry_ReflectionEnumUnitCase) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionEnumBackedCase", class_ReflectionEnumBackedCase_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionEnumBackedCase"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionEnumBackedCase_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ReflectionEnumUnitCase, 0); return class_entry; @@ -1880,8 +1942,10 @@ static zend_class_entry *register_class_ReflectionEnumBackedCase(zend_class_entr static zend_class_entry *register_class_ReflectionFiber(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionFiber", class_ReflectionFiber_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionFiber"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionFiber_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -1890,8 +1954,10 @@ static zend_class_entry *register_class_ReflectionFiber(void) static zend_class_entry *register_class_ReflectionConstant(zend_class_entry *class_entry_Reflector) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ReflectionConstant", class_ReflectionConstant_methods); + INIT_CLASS_NAME(namespaced_name, "ReflectionConstant"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ReflectionConstant_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Reflector); diff --git a/ext/reflection/tests/ReflectionClass_toString_001.phpt b/ext/reflection/tests/ReflectionClass_toString_001.phpt index fd5d83e917419..2a77633245d03 100644 --- a/ext/reflection/tests/ReflectionClass_toString_001.phpt +++ b/ext/reflection/tests/ReflectionClass_toString_001.phpt @@ -30,7 +30,7 @@ Class [ class ReflectionClass implements Stringable, Refle Property [ public string $name ] } - - Methods [64] { + - Methods [68] { Method [ private method __clone ] { - Parameters [0] { @@ -514,5 +514,33 @@ Class [ class ReflectionClass implements Stringable, Refle } - Return [ array ] } + + Method [ public method isInnerClass ] { + + - Parameters [0] { + } + - Return [ bool ] + } + + Method [ public method isPrivate ] { + + - Parameters [0] { + } + - Return [ bool ] + } + + Method [ public method isProtected ] { + + - Parameters [0] { + } + - Return [ bool ] + } + + Method [ public method isPublic ] { + + - Parameters [0] { + } + - Return [ bool ] + } } } diff --git a/ext/reflection/tests/bug74454.phpt b/ext/reflection/tests/bug74454.phpt index 272409339c479..f1116becf6ce8 100644 --- a/ext/reflection/tests/bug74454.phpt +++ b/ext/reflection/tests/bug74454.phpt @@ -14,4 +14,4 @@ function load_file() { } ?> --EXPECT-- -ParseError: syntax error, unexpected token "if", expecting "function" +ParseError: syntax error, unexpected token "if", expecting "class" diff --git a/ext/session/session.c b/ext/session/session.c index fd877483c0a6f..d1e958d1b6b8c 100644 --- a/ext/session/session.c +++ b/ext/session/session.c @@ -2062,7 +2062,7 @@ PHP_FUNCTION(session_set_save_handler) if (PS(mod_user_class_name)) { zend_string_release(PS(mod_user_class_name)); } - PS(mod_user_class_name) = zend_string_copy(Z_OBJCE_P(obj)->name); + PS(mod_user_class_name) = zend_string_copy(Z_OBJCE_P(obj)->namespaced_name.name); /* Define mandatory handlers */ SESSION_SET_USER_HANDLER_OO_MANDATORY(ps_open, "open"); diff --git a/ext/session/session_arginfo.h b/ext/session/session_arginfo.h index 3e0c889ae3c55..82a5acddb4326 100644 --- a/ext/session/session_arginfo.h +++ b/ext/session/session_arginfo.h @@ -234,8 +234,10 @@ static void register_session_symbols(int module_number) static zend_class_entry *register_class_SessionHandlerInterface(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SessionHandlerInterface", class_SessionHandlerInterface_methods); + INIT_CLASS_NAME(namespaced_name, "SessionHandlerInterface"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SessionHandlerInterface_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -244,8 +246,10 @@ static zend_class_entry *register_class_SessionHandlerInterface(void) static zend_class_entry *register_class_SessionIdInterface(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SessionIdInterface", class_SessionIdInterface_methods); + INIT_CLASS_NAME(namespaced_name, "SessionIdInterface"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SessionIdInterface_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -254,8 +258,10 @@ static zend_class_entry *register_class_SessionIdInterface(void) static zend_class_entry *register_class_SessionUpdateTimestampHandlerInterface(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SessionUpdateTimestampHandlerInterface", class_SessionUpdateTimestampHandlerInterface_methods); + INIT_CLASS_NAME(namespaced_name, "SessionUpdateTimestampHandlerInterface"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SessionUpdateTimestampHandlerInterface_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -264,8 +270,10 @@ static zend_class_entry *register_class_SessionUpdateTimestampHandlerInterface(v static zend_class_entry *register_class_SessionHandler(zend_class_entry *class_entry_SessionHandlerInterface, zend_class_entry *class_entry_SessionIdInterface) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SessionHandler", class_SessionHandler_methods); + INIT_CLASS_NAME(namespaced_name, "SessionHandler"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SessionHandler_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 2, class_entry_SessionHandlerInterface, class_entry_SessionIdInterface); diff --git a/ext/shmop/shmop_arginfo.h b/ext/shmop/shmop_arginfo.h index 54bb2e19d5465..c33b9923b1f95 100644 --- a/ext/shmop/shmop_arginfo.h +++ b/ext/shmop/shmop_arginfo.h @@ -68,8 +68,10 @@ static void register_shmop_symbols(int module_number) static zend_class_entry *register_class_Shmop(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Shmop", NULL); + INIT_CLASS_NAME(namespaced_name, "Shmop"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/simplexml/simplexml_arginfo.h b/ext/simplexml/simplexml_arginfo.h index 379307f953a10..5ff612e9b2f96 100644 --- a/ext/simplexml/simplexml_arginfo.h +++ b/ext/simplexml/simplexml_arginfo.h @@ -159,8 +159,10 @@ static const zend_function_entry class_SimpleXMLElement_methods[] = { static zend_class_entry *register_class_SimpleXMLElement(zend_class_entry *class_entry_Stringable, zend_class_entry *class_entry_Countable, zend_class_entry *class_entry_RecursiveIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SimpleXMLElement", class_SimpleXMLElement_methods); + INIT_CLASS_NAME(namespaced_name, "SimpleXMLElement"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SimpleXMLElement_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 3, class_entry_Stringable, class_entry_Countable, class_entry_RecursiveIterator); @@ -170,8 +172,10 @@ static zend_class_entry *register_class_SimpleXMLElement(zend_class_entry *class static zend_class_entry *register_class_SimpleXMLIterator(zend_class_entry *class_entry_SimpleXMLElement) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SimpleXMLIterator", NULL); + INIT_CLASS_NAME(namespaced_name, "SimpleXMLIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_SimpleXMLElement, 0); return class_entry; diff --git a/ext/snmp/snmp_arginfo.h b/ext/snmp/snmp_arginfo.h index 18ed9c7356634..c5bbc1aae7370 100644 --- a/ext/snmp/snmp_arginfo.h +++ b/ext/snmp/snmp_arginfo.h @@ -264,8 +264,10 @@ static void register_snmp_symbols(int module_number) static zend_class_entry *register_class_SNMP(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SNMP", class_SNMP_methods); + INIT_CLASS_NAME(namespaced_name, "SNMP"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SNMP_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval const_VERSION_1_value; @@ -394,8 +396,10 @@ static zend_class_entry *register_class_SNMP(void) static zend_class_entry *register_class_SNMPException(zend_class_entry *class_entry_RuntimeException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SNMPException", NULL); + INIT_CLASS_NAME(namespaced_name, "SNMPException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RuntimeException, 0); return class_entry; diff --git a/ext/soap/soap_arginfo.h b/ext/soap/soap_arginfo.h index 9ec093c5c9cd2..9afc5cb35c0e5 100644 --- a/ext/soap/soap_arginfo.h +++ b/ext/soap/soap_arginfo.h @@ -318,8 +318,10 @@ static void register_soap_symbols(int module_number) static zend_class_entry *register_class_Soap_Url(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Soap", "Url", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Soap", "Url"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -328,8 +330,10 @@ static zend_class_entry *register_class_Soap_Url(void) static zend_class_entry *register_class_Soap_Sdl(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "Soap", "Sdl", NULL); + INIT_CLASS_NAME_NS(namespaced_name, "Soap", "Sdl"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -338,8 +342,10 @@ static zend_class_entry *register_class_Soap_Sdl(void) static zend_class_entry *register_class_SoapParam(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SoapParam", class_SoapParam_methods); + INIT_CLASS_NAME(namespaced_name, "SoapParam"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SoapParam_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_param_name_default_value; @@ -360,8 +366,10 @@ static zend_class_entry *register_class_SoapParam(void) static zend_class_entry *register_class_SoapHeader(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SoapHeader", class_SoapHeader_methods); + INIT_CLASS_NAME(namespaced_name, "SoapHeader"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SoapHeader_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_namespace_default_value; @@ -398,8 +406,10 @@ static zend_class_entry *register_class_SoapHeader(void) static zend_class_entry *register_class_SoapFault(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SoapFault", class_SoapFault_methods); + INIT_CLASS_NAME(namespaced_name, "SoapFault"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SoapFault_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, 0); zval property_faultstring_default_value; @@ -450,8 +460,10 @@ static zend_class_entry *register_class_SoapFault(zend_class_entry *class_entry_ static zend_class_entry *register_class_SoapVar(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SoapVar", class_SoapVar_methods); + INIT_CLASS_NAME(namespaced_name, "SoapVar"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SoapVar_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_enc_type_default_value; @@ -496,8 +508,10 @@ static zend_class_entry *register_class_SoapVar(void) static zend_class_entry *register_class_SoapServer(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SoapServer", class_SoapServer_methods); + INIT_CLASS_NAME(namespaced_name, "SoapServer"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SoapServer_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property___soap_fault_default_value; @@ -513,8 +527,10 @@ static zend_class_entry *register_class_SoapServer(void) static zend_class_entry *register_class_SoapClient(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SoapClient", class_SoapClient_methods); + INIT_CLASS_NAME(namespaced_name, "SoapClient"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SoapClient_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_uri_default_value; diff --git a/ext/sockets/sockets_arginfo.h b/ext/sockets/sockets_arginfo.h index 45714fb285174..ff9bd40de2b1b 100644 --- a/ext/sockets/sockets_arginfo.h +++ b/ext/sockets/sockets_arginfo.h @@ -1113,8 +1113,10 @@ static void register_sockets_symbols(int module_number) static zend_class_entry *register_class_Socket(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Socket", NULL); + INIT_CLASS_NAME(namespaced_name, "Socket"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -1123,8 +1125,10 @@ static zend_class_entry *register_class_Socket(void) static zend_class_entry *register_class_AddressInfo(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "AddressInfo", NULL); + INIT_CLASS_NAME(namespaced_name, "AddressInfo"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/sodium/libsodium_arginfo.h b/ext/sodium/libsodium_arginfo.h index f91a7c5dfe0d9..a1df1fdbe387e 100644 --- a/ext/sodium/libsodium_arginfo.h +++ b/ext/sodium/libsodium_arginfo.h @@ -1147,8 +1147,10 @@ static void register_libsodium_symbols(int module_number) static zend_class_entry *register_class_SodiumException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SodiumException", NULL); + INIT_CLASS_NAME(namespaced_name, "SodiumException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, 0); return class_entry; diff --git a/ext/spl/php_spl.c b/ext/spl/php_spl.c index 1149be29bd46e..237594062d56c 100644 --- a/ext/spl/php_spl.c +++ b/ext/spl/php_spl.c @@ -630,7 +630,7 @@ PHP_FUNCTION(spl_autoload_functions) GC_ADDREF(alfi->obj); add_next_index_object(&tmp, alfi->obj); } else { - add_next_index_str(&tmp, zend_string_copy(alfi->ce->name)); + add_next_index_str(&tmp, zend_string_copy(alfi->ce->namespaced_name.name)); } add_next_index_str(&tmp, zend_string_copy(alfi->func_ptr->common.function_name)); add_next_index_zval(return_value, &tmp); diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c index 937e9f41b845e..d248afaed1912 100644 --- a/ext/spl/spl_array.c +++ b/ext/spl/spl_array.c @@ -443,7 +443,7 @@ static zval *spl_array_read_dimension_ex(int check_inherited, zend_object *objec } } - ret = spl_array_get_dimension_ptr(check_inherited, intern, object->ce->name, offset, type); + ret = spl_array_get_dimension_ptr(check_inherited, intern, object->ce->namespaced_name.name, offset, type); /* When in a write context, * ZE has to be fooled into thinking this is in a reference set @@ -520,7 +520,7 @@ static void spl_array_write_dimension_ex(int check_inherited, zend_object *objec } if (get_hash_key(&key, intern, offset) == FAILURE) { - zend_illegal_container_offset(object->ce->name, offset, BP_VAR_W); + zend_illegal_container_offset(object->ce->namespaced_name.name, offset, BP_VAR_W); zval_ptr_dtor(value); return; } @@ -565,7 +565,7 @@ static void spl_array_unset_dimension_ex(int check_inherited, zend_object *objec } if (get_hash_key(&key, intern, offset) == FAILURE) { - zend_illegal_container_offset(object->ce->name, offset, BP_VAR_UNSET); + zend_illegal_container_offset(object->ce->namespaced_name.name, offset, BP_VAR_UNSET); return; } @@ -637,7 +637,7 @@ static bool spl_array_has_dimension_ex(bool check_inherited, zend_object *object spl_hash_key key; if (get_hash_key(&key, intern, offset) == FAILURE) { - zend_illegal_container_offset(object->ce->name, offset, BP_VAR_IS); + zend_illegal_container_offset(object->ce->namespaced_name.name, offset, BP_VAR_IS); return 0; } @@ -718,7 +718,7 @@ void spl_array_iterator_append(zval *object, zval *append_value) /* {{{ */ spl_array_object *intern = Z_SPLARRAY_P(object); if (spl_array_is_object(intern)) { - zend_throw_error(NULL, "Cannot append properties to objects, use %s::offsetSet() instead", ZSTR_VAL(Z_OBJCE_P(object)->name)); + zend_throw_error(NULL, "Cannot append properties to objects, use %s::offsetSet() instead", ZSTR_VAL(Z_OBJCE_P(object)->namespaced_name.name)); return; } @@ -872,7 +872,7 @@ static zval *spl_array_get_property_ptr_ptr(zend_object *object, zend_string *na return NULL; } ZVAL_STR(&member, name); - return spl_array_get_dimension_ptr(1, intern, object->ce->name, &member, type); + return spl_array_get_dimension_ptr(1, intern, object->ce->namespaced_name.name, &member, type); } return zend_std_get_property_ptr_ptr(object, name, type, cache_slot); } /* }}} */ @@ -1000,14 +1000,14 @@ static void spl_array_set_array(zval *object, spl_array_object *intern, zval *ar if (handler != zend_std_get_properties || Z_OBJ_HANDLER_P(array, get_properties_for)) { zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Overloaded object of type %s is not compatible with %s", - ZSTR_VAL(Z_OBJCE_P(array)->name), ZSTR_VAL(intern->std.ce->name)); + ZSTR_VAL(Z_OBJCE_P(array)->namespaced_name.name), ZSTR_VAL(intern->std.ce->namespaced_name.name)); ZEND_ASSERT(Z_TYPE(garbage) == IS_UNDEF); return; } if (UNEXPECTED(Z_OBJCE_P(array)->ce_flags & ZEND_ACC_ENUM)) { zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0, "Enums are not compatible with %s", - ZSTR_VAL(intern->std.ce->name)); + ZSTR_VAL(intern->std.ce->namespaced_name.name)); ZEND_ASSERT(Z_TYPE(garbage) == IS_UNDEF); return; } @@ -1081,8 +1081,8 @@ PHP_METHOD(ArrayObject, getIteratorClass) RETURN_THROWS(); } - zend_string_addref(intern->ce_get_iterator->name); - RETURN_STR(intern->ce_get_iterator->name); + zend_string_addref(intern->ce_get_iterator->namespaced_name.name); + RETURN_STR(intern->ce_get_iterator->namespaced_name.name); } /* }}} */ @@ -1461,7 +1461,7 @@ PHP_METHOD(ArrayObject, __serialize) if (intern->ce_get_iterator == spl_ce_ArrayIterator) { ZVAL_NULL(&tmp); } else { - ZVAL_STR_COPY(&tmp, intern->ce_get_iterator->name); + ZVAL_STR_COPY(&tmp, intern->ce_get_iterator->namespaced_name.name); } zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp); } @@ -1611,7 +1611,7 @@ static zval *spl_array_it_get_current_data(zend_object_iterator *iter) /* {{{ */ if (prop_info->flags & ZEND_ACC_READONLY) { zend_throw_error(NULL, "Cannot acquire reference to readonly property %s::$%s", - ZSTR_VAL(prop_info->ce->name), ZSTR_VAL(key)); + ZSTR_VAL(prop_info->ce->namespaced_name.name), ZSTR_VAL(key)); return NULL; } ZVAL_NEW_REF(data, data); diff --git a/ext/spl/spl_array_arginfo.h b/ext/spl/spl_array_arginfo.h index 24dcadac661c8..001beb5486eca 100644 --- a/ext/spl/spl_array_arginfo.h +++ b/ext/spl/spl_array_arginfo.h @@ -257,8 +257,10 @@ static const zend_function_entry class_RecursiveArrayIterator_methods[] = { static zend_class_entry *register_class_ArrayObject(zend_class_entry *class_entry_IteratorAggregate, zend_class_entry *class_entry_ArrayAccess, zend_class_entry *class_entry_Serializable, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ArrayObject", class_ArrayObject_methods); + INIT_CLASS_NAME(namespaced_name, "ArrayObject"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ArrayObject_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 4, class_entry_IteratorAggregate, class_entry_ArrayAccess, class_entry_Serializable, class_entry_Countable); @@ -280,8 +282,10 @@ static zend_class_entry *register_class_ArrayObject(zend_class_entry *class_entr static zend_class_entry *register_class_ArrayIterator(zend_class_entry *class_entry_SeekableIterator, zend_class_entry *class_entry_ArrayAccess, zend_class_entry *class_entry_Serializable, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ArrayIterator", class_ArrayIterator_methods); + INIT_CLASS_NAME(namespaced_name, "ArrayIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ArrayIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 4, class_entry_SeekableIterator, class_entry_ArrayAccess, class_entry_Serializable, class_entry_Countable); @@ -303,8 +307,10 @@ static zend_class_entry *register_class_ArrayIterator(zend_class_entry *class_en static zend_class_entry *register_class_RecursiveArrayIterator(zend_class_entry *class_entry_ArrayIterator, zend_class_entry *class_entry_RecursiveIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RecursiveArrayIterator", class_RecursiveArrayIterator_methods); + INIT_CLASS_NAME(namespaced_name, "RecursiveArrayIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_RecursiveArrayIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ArrayIterator, 0); zend_class_implements(class_entry, 1, class_entry_RecursiveIterator); diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c index 461bdc1e901ec..c76014aac596e 100644 --- a/ext/spl/spl_directory.c +++ b/ext/spl/spl_directory.c @@ -1369,7 +1369,7 @@ PHP_METHOD(SplFileInfo, getPathInfo) if (ce == NULL) { ce = intern->info_class; } else if (!instanceof_function(ce, spl_ce_SplFileInfo)) { - zend_argument_type_error(1, "must be a class name derived from %s or null, %s given", ZSTR_VAL(spl_ce_SplFileInfo->name), ZSTR_VAL(ce->name)); + zend_argument_type_error(1, "must be a class name derived from %s or null, %s given", ZSTR_VAL(spl_ce_SplFileInfo->namespaced_name.name), ZSTR_VAL(ce->namespaced_name.name)); RETURN_THROWS(); } @@ -1971,7 +1971,7 @@ static zend_result spl_filesystem_file_read_line_ex(zval * this_ptr, spl_filesys if (Z_TYPE(retval) != IS_STRING) { zend_type_error("%s::getCurrentLine(): Return value must be of type string, %s returned", - ZSTR_VAL(Z_OBJCE_P(this_ptr)->name), zend_zval_value_name(&retval)); + ZSTR_VAL(Z_OBJCE_P(this_ptr)->namespaced_name.name), zend_zval_value_name(&retval)); zval_ptr_dtor(&retval); return FAILURE; } diff --git a/ext/spl/spl_directory_arginfo.h b/ext/spl/spl_directory_arginfo.h index e9287e7ea9483..ddaa029f19d8b 100644 --- a/ext/spl/spl_directory_arginfo.h +++ b/ext/spl/spl_directory_arginfo.h @@ -482,8 +482,10 @@ static const zend_function_entry class_SplTempFileObject_methods[] = { static zend_class_entry *register_class_SplFileInfo(zend_class_entry *class_entry_Stringable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplFileInfo", class_SplFileInfo_methods); + INIT_CLASS_NAME(namespaced_name, "SplFileInfo"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplFileInfo_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zend_class_implements(class_entry, 1, class_entry_Stringable); @@ -501,8 +503,10 @@ static zend_class_entry *register_class_SplFileInfo(zend_class_entry *class_entr static zend_class_entry *register_class_DirectoryIterator(zend_class_entry *class_entry_SplFileInfo, zend_class_entry *class_entry_SeekableIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DirectoryIterator", class_DirectoryIterator_methods); + INIT_CLASS_NAME(namespaced_name, "DirectoryIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DirectoryIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_SplFileInfo, 0); zend_class_implements(class_entry, 1, class_entry_SeekableIterator); @@ -512,8 +516,10 @@ static zend_class_entry *register_class_DirectoryIterator(zend_class_entry *clas static zend_class_entry *register_class_FilesystemIterator(zend_class_entry *class_entry_DirectoryIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "FilesystemIterator", class_FilesystemIterator_methods); + INIT_CLASS_NAME(namespaced_name, "FilesystemIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_FilesystemIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_DirectoryIterator, 0); zval const_CURRENT_MODE_MASK_value; @@ -594,8 +600,10 @@ static zend_class_entry *register_class_FilesystemIterator(zend_class_entry *cla static zend_class_entry *register_class_RecursiveDirectoryIterator(zend_class_entry *class_entry_FilesystemIterator, zend_class_entry *class_entry_RecursiveIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RecursiveDirectoryIterator", class_RecursiveDirectoryIterator_methods); + INIT_CLASS_NAME(namespaced_name, "RecursiveDirectoryIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_RecursiveDirectoryIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_FilesystemIterator, 0); zend_class_implements(class_entry, 1, class_entry_RecursiveIterator); @@ -606,8 +614,10 @@ static zend_class_entry *register_class_RecursiveDirectoryIterator(zend_class_en static zend_class_entry *register_class_GlobIterator(zend_class_entry *class_entry_FilesystemIterator, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "GlobIterator", class_GlobIterator_methods); + INIT_CLASS_NAME(namespaced_name, "GlobIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_GlobIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_FilesystemIterator, 0); zend_class_implements(class_entry, 1, class_entry_Countable); @@ -618,8 +628,10 @@ static zend_class_entry *register_class_GlobIterator(zend_class_entry *class_ent static zend_class_entry *register_class_SplFileObject(zend_class_entry *class_entry_SplFileInfo, zend_class_entry *class_entry_RecursiveIterator, zend_class_entry *class_entry_SeekableIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplFileObject", class_SplFileObject_methods); + INIT_CLASS_NAME(namespaced_name, "SplFileObject"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplFileObject_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_SplFileInfo, 0); zend_class_implements(class_entry, 2, class_entry_RecursiveIterator, class_entry_SeekableIterator); @@ -653,8 +665,10 @@ static zend_class_entry *register_class_SplFileObject(zend_class_entry *class_en static zend_class_entry *register_class_SplTempFileObject(zend_class_entry *class_entry_SplFileObject) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplTempFileObject", class_SplTempFileObject_methods); + INIT_CLASS_NAME(namespaced_name, "SplTempFileObject"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplTempFileObject_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_SplFileObject, 0); return class_entry; diff --git a/ext/spl/spl_dllist_arginfo.h b/ext/spl/spl_dllist_arginfo.h index a5b1510655138..a24365c73b424 100644 --- a/ext/spl/spl_dllist_arginfo.h +++ b/ext/spl/spl_dllist_arginfo.h @@ -149,8 +149,10 @@ static const zend_function_entry class_SplQueue_methods[] = { static zend_class_entry *register_class_SplDoublyLinkedList(zend_class_entry *class_entry_Iterator, zend_class_entry *class_entry_Countable, zend_class_entry *class_entry_ArrayAccess, zend_class_entry *class_entry_Serializable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplDoublyLinkedList", class_SplDoublyLinkedList_methods); + INIT_CLASS_NAME(namespaced_name, "SplDoublyLinkedList"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplDoublyLinkedList_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 4, class_entry_Iterator, class_entry_Countable, class_entry_ArrayAccess, class_entry_Serializable); @@ -184,8 +186,10 @@ static zend_class_entry *register_class_SplDoublyLinkedList(zend_class_entry *cl static zend_class_entry *register_class_SplQueue(zend_class_entry *class_entry_SplDoublyLinkedList) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplQueue", class_SplQueue_methods); + INIT_CLASS_NAME(namespaced_name, "SplQueue"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplQueue_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_SplDoublyLinkedList, 0); return class_entry; @@ -194,8 +198,10 @@ static zend_class_entry *register_class_SplQueue(zend_class_entry *class_entry_S static zend_class_entry *register_class_SplStack(zend_class_entry *class_entry_SplDoublyLinkedList) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplStack", NULL); + INIT_CLASS_NAME(namespaced_name, "SplStack"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_SplDoublyLinkedList, 0); return class_entry; diff --git a/ext/spl/spl_exceptions_arginfo.h b/ext/spl/spl_exceptions_arginfo.h index 568a91719aee8..ff7b71af6ea4c 100644 --- a/ext/spl/spl_exceptions_arginfo.h +++ b/ext/spl/spl_exceptions_arginfo.h @@ -4,8 +4,10 @@ static zend_class_entry *register_class_LogicException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "LogicException", NULL); + INIT_CLASS_NAME(namespaced_name, "LogicException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, 0); return class_entry; @@ -14,8 +16,10 @@ static zend_class_entry *register_class_LogicException(zend_class_entry *class_e static zend_class_entry *register_class_BadFunctionCallException(zend_class_entry *class_entry_LogicException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "BadFunctionCallException", NULL); + INIT_CLASS_NAME(namespaced_name, "BadFunctionCallException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_LogicException, 0); return class_entry; @@ -24,8 +28,10 @@ static zend_class_entry *register_class_BadFunctionCallException(zend_class_entr static zend_class_entry *register_class_BadMethodCallException(zend_class_entry *class_entry_BadFunctionCallException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "BadMethodCallException", NULL); + INIT_CLASS_NAME(namespaced_name, "BadMethodCallException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_BadFunctionCallException, 0); return class_entry; @@ -34,8 +40,10 @@ static zend_class_entry *register_class_BadMethodCallException(zend_class_entry static zend_class_entry *register_class_DomainException(zend_class_entry *class_entry_LogicException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DomainException", NULL); + INIT_CLASS_NAME(namespaced_name, "DomainException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_LogicException, 0); return class_entry; @@ -44,8 +52,10 @@ static zend_class_entry *register_class_DomainException(zend_class_entry *class_ static zend_class_entry *register_class_InvalidArgumentException(zend_class_entry *class_entry_LogicException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "InvalidArgumentException", NULL); + INIT_CLASS_NAME(namespaced_name, "InvalidArgumentException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_LogicException, 0); return class_entry; @@ -54,8 +64,10 @@ static zend_class_entry *register_class_InvalidArgumentException(zend_class_entr static zend_class_entry *register_class_LengthException(zend_class_entry *class_entry_LogicException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "LengthException", NULL); + INIT_CLASS_NAME(namespaced_name, "LengthException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_LogicException, 0); return class_entry; @@ -64,8 +76,10 @@ static zend_class_entry *register_class_LengthException(zend_class_entry *class_ static zend_class_entry *register_class_OutOfRangeException(zend_class_entry *class_entry_LogicException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "OutOfRangeException", NULL); + INIT_CLASS_NAME(namespaced_name, "OutOfRangeException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_LogicException, 0); return class_entry; @@ -74,8 +88,10 @@ static zend_class_entry *register_class_OutOfRangeException(zend_class_entry *cl static zend_class_entry *register_class_RuntimeException(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RuntimeException", NULL); + INIT_CLASS_NAME(namespaced_name, "RuntimeException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, 0); return class_entry; @@ -84,8 +100,10 @@ static zend_class_entry *register_class_RuntimeException(zend_class_entry *class static zend_class_entry *register_class_OutOfBoundsException(zend_class_entry *class_entry_RuntimeException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "OutOfBoundsException", NULL); + INIT_CLASS_NAME(namespaced_name, "OutOfBoundsException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RuntimeException, 0); return class_entry; @@ -94,8 +112,10 @@ static zend_class_entry *register_class_OutOfBoundsException(zend_class_entry *c static zend_class_entry *register_class_OverflowException(zend_class_entry *class_entry_RuntimeException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "OverflowException", NULL); + INIT_CLASS_NAME(namespaced_name, "OverflowException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RuntimeException, 0); return class_entry; @@ -104,8 +124,10 @@ static zend_class_entry *register_class_OverflowException(zend_class_entry *clas static zend_class_entry *register_class_RangeException(zend_class_entry *class_entry_RuntimeException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RangeException", NULL); + INIT_CLASS_NAME(namespaced_name, "RangeException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RuntimeException, 0); return class_entry; @@ -114,8 +136,10 @@ static zend_class_entry *register_class_RangeException(zend_class_entry *class_e static zend_class_entry *register_class_UnderflowException(zend_class_entry *class_entry_RuntimeException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "UnderflowException", NULL); + INIT_CLASS_NAME(namespaced_name, "UnderflowException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RuntimeException, 0); return class_entry; @@ -124,8 +148,10 @@ static zend_class_entry *register_class_UnderflowException(zend_class_entry *cla static zend_class_entry *register_class_UnexpectedValueException(zend_class_entry *class_entry_RuntimeException) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "UnexpectedValueException", NULL); + INIT_CLASS_NAME(namespaced_name, "UnexpectedValueException"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RuntimeException, 0); return class_entry; diff --git a/ext/spl/spl_fixedarray.c b/ext/spl/spl_fixedarray.c index b919501c0dd25..af5f33f5b3485 100644 --- a/ext/spl/spl_fixedarray.c +++ b/ext/spl/spl_fixedarray.c @@ -352,7 +352,7 @@ static zend_long spl_offset_convert_to_long(zval *offset) /* {{{ */ } /* Use SplFixedArray name from the CE */ - zend_illegal_container_offset(spl_ce_SplFixedArray->name, offset, BP_VAR_R); + zend_illegal_container_offset(spl_ce_SplFixedArray->namespaced_name.name, offset, BP_VAR_R); return 0; } diff --git a/ext/spl/spl_fixedarray_arginfo.h b/ext/spl/spl_fixedarray_arginfo.h index 5d83183d91b81..80fa67785fa52 100644 --- a/ext/spl/spl_fixedarray_arginfo.h +++ b/ext/spl/spl_fixedarray_arginfo.h @@ -92,8 +92,10 @@ static const zend_function_entry class_SplFixedArray_methods[] = { static zend_class_entry *register_class_SplFixedArray(zend_class_entry *class_entry_IteratorAggregate, zend_class_entry *class_entry_ArrayAccess, zend_class_entry *class_entry_Countable, zend_class_entry *class_entry_JsonSerializable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplFixedArray", class_SplFixedArray_methods); + INIT_CLASS_NAME(namespaced_name, "SplFixedArray"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplFixedArray_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 4, class_entry_IteratorAggregate, class_entry_ArrayAccess, class_entry_Countable, class_entry_JsonSerializable); diff --git a/ext/spl/spl_functions.c b/ext/spl/spl_functions.c index e7ecbc33f92ef..81a845c9de0e1 100644 --- a/ext/spl/spl_functions.c +++ b/ext/spl/spl_functions.c @@ -26,10 +26,10 @@ void spl_add_class_name(zval *list, zend_class_entry *pce, int allow, int ce_fla if (!allow || (allow > 0 && (pce->ce_flags & ce_flags)) || (allow < 0 && !(pce->ce_flags & ce_flags))) { zval *tmp; - if ((tmp = zend_hash_find(Z_ARRVAL_P(list), pce->name)) == NULL) { + if ((tmp = zend_hash_find(Z_ARRVAL_P(list), pce->namespaced_name.name)) == NULL) { zval t; - ZVAL_STR_COPY(&t, pce->name); - zend_hash_add(Z_ARRVAL_P(list), pce->name, &t); + ZVAL_STR_COPY(&t, pce->namespaced_name.name); + zend_hash_add(Z_ARRVAL_P(list), pce->namespaced_name.name, &t); } } } @@ -54,7 +54,7 @@ void spl_add_traits(zval *list, zend_class_entry * pce, int allow, int ce_flags) for (uint32_t num_traits = 0; num_traits < pce->num_traits; num_traits++) { trait = zend_fetch_class_by_name(pce->trait_names[num_traits].name, - pce->trait_names[num_traits].lc_name, ZEND_FETCH_CLASS_TRAIT); + pce->trait_names[num_traits].resolved_name, ZEND_FETCH_CLASS_TRAIT); ZEND_ASSERT(trait); spl_add_class_name(list, trait, allow, ce_flags); } @@ -86,8 +86,8 @@ void spl_set_private_debug_info_property( ) { zend_string *mangled_named = zend_mangle_property_name( - ZSTR_VAL(ce->name), - ZSTR_LEN(ce->name), + ZSTR_VAL(ce->namespaced_name.name), + ZSTR_LEN(ce->namespaced_name.name), property, property_len, /* persistent */ false diff --git a/ext/spl/spl_heap_arginfo.h b/ext/spl/spl_heap_arginfo.h index 31a3f79fe2c75..f48835592e5ed 100644 --- a/ext/spl/spl_heap_arginfo.h +++ b/ext/spl/spl_heap_arginfo.h @@ -159,8 +159,10 @@ static const zend_function_entry class_SplMaxHeap_methods[] = { static zend_class_entry *register_class_SplPriorityQueue(zend_class_entry *class_entry_Iterator, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplPriorityQueue", class_SplPriorityQueue_methods); + INIT_CLASS_NAME(namespaced_name, "SplPriorityQueue"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplPriorityQueue_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 2, class_entry_Iterator, class_entry_Countable); @@ -188,8 +190,10 @@ static zend_class_entry *register_class_SplPriorityQueue(zend_class_entry *class static zend_class_entry *register_class_SplHeap(zend_class_entry *class_entry_Iterator, zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplHeap", class_SplHeap_methods); + INIT_CLASS_NAME(namespaced_name, "SplHeap"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplHeap_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_ABSTRACT); zend_class_implements(class_entry, 2, class_entry_Iterator, class_entry_Countable); @@ -199,8 +203,10 @@ static zend_class_entry *register_class_SplHeap(zend_class_entry *class_entry_It static zend_class_entry *register_class_SplMinHeap(zend_class_entry *class_entry_SplHeap) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplMinHeap", class_SplMinHeap_methods); + INIT_CLASS_NAME(namespaced_name, "SplMinHeap"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplMinHeap_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_SplHeap, 0); return class_entry; @@ -209,8 +215,10 @@ static zend_class_entry *register_class_SplMinHeap(zend_class_entry *class_entry static zend_class_entry *register_class_SplMaxHeap(zend_class_entry *class_entry_SplHeap) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplMaxHeap", class_SplMaxHeap_methods); + INIT_CLASS_NAME(namespaced_name, "SplMaxHeap"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplMaxHeap_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_SplHeap, 0); return class_entry; diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c index d0491f625529b..a6a33b09d19a9 100644 --- a/ext/spl/spl_iterators.c +++ b/ext/spl/spl_iterators.c @@ -517,7 +517,7 @@ static zend_result spl_get_iterator_from_aggregate(zval *retval, zend_class_entr || !instanceof_function(Z_OBJCE_P(retval), zend_ce_traversable)) { zend_throw_exception_ex(spl_ce_LogicException, 0, "%s::getIterator() must return an object that implements Traversable", - ZSTR_VAL(ce->name)); + ZSTR_VAL(ce->namespaced_name.name)); zval_ptr_dtor(retval); return FAILURE; } @@ -897,7 +897,7 @@ static zend_function *spl_recursive_it_get_method(zend_object **zobject, zend_st zval *zobj; if (!object->iterators) { - zend_throw_error(NULL, "The %s instance wasn't initialized properly", ZSTR_VAL((*zobject)->ce->name)); + zend_throw_error(NULL, "The %s instance wasn't initialized properly", ZSTR_VAL((*zobject)->ce->namespaced_name.name)); return NULL; } zobj = &object->iterators[level].zobject; @@ -1243,7 +1243,7 @@ static zend_function *spl_dual_it_get_method(zend_object **object, zend_string * if (intern->dit_type == DIT_Unknown) { \ /* TODO Normal Error? */ \ zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Classes derived from %s must call %s::__construct()", \ - ZSTR_VAL((spl_ce_##classname)->name), ZSTR_VAL((spl_ce_##classname)->name)); \ + ZSTR_VAL((spl_ce_##classname)->namespaced_name.name), ZSTR_VAL((spl_ce_##classname)->namespaced_name.name)); \ RETURN_THROWS(); \ } @@ -1274,7 +1274,7 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z intern = Z_SPLDUAL_IT_P(ZEND_THIS); if (intern->dit_type != DIT_Unknown) { - zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s::getIterator() must be called exactly once per instance", ZSTR_VAL(ce_base->name)); + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s::getIterator() must be called exactly once per instance", ZSTR_VAL(ce_base->namespaced_name.name)); return NULL; } @@ -2390,7 +2390,7 @@ PHP_METHOD(CachingIterator, __toString) SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS); if (!(intern->u.caching.flags & (CIT_CALL_TOSTRING|CIT_TOSTRING_USE_KEY|CIT_TOSTRING_USE_CURRENT|CIT_TOSTRING_USE_INNER))) { - zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not fetch string value (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name)); + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not fetch string value (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->namespaced_name.name)); RETURN_THROWS(); } @@ -2424,7 +2424,7 @@ PHP_METHOD(CachingIterator, offsetSet) SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS); if (!(intern->u.caching.flags & CIT_FULL_CACHE)) { - zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name)); + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->namespaced_name.name)); RETURN_THROWS(); } @@ -2447,7 +2447,7 @@ PHP_METHOD(CachingIterator, offsetGet) SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS); if (!(intern->u.caching.flags & CIT_FULL_CACHE)) { - zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name)); + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->namespaced_name.name)); RETURN_THROWS(); } @@ -2473,7 +2473,7 @@ PHP_METHOD(CachingIterator, offsetUnset) } if (!(intern->u.caching.flags & CIT_FULL_CACHE)) { - zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name)); + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->namespaced_name.name)); RETURN_THROWS(); } @@ -2494,7 +2494,7 @@ PHP_METHOD(CachingIterator, offsetExists) SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS); if (!(intern->u.caching.flags & CIT_FULL_CACHE)) { - zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name)); + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->namespaced_name.name)); RETURN_THROWS(); } @@ -2512,7 +2512,7 @@ PHP_METHOD(CachingIterator, getCache) SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS); if (!(intern->u.caching.flags & CIT_FULL_CACHE)) { - zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name)); + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->namespaced_name.name)); RETURN_THROWS(); } @@ -2577,7 +2577,7 @@ PHP_METHOD(CachingIterator, count) SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS); if (!(intern->u.caching.flags & CIT_FULL_CACHE)) { - zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name)); + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "%s does not use a full cache (see CachingIterator::__construct)", ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->namespaced_name.name)); RETURN_THROWS(); } diff --git a/ext/spl/spl_iterators_arginfo.h b/ext/spl/spl_iterators_arginfo.h index 439236643471e..9e743d1538025 100644 --- a/ext/spl/spl_iterators_arginfo.h +++ b/ext/spl/spl_iterators_arginfo.h @@ -603,8 +603,10 @@ static const zend_function_entry class_RecursiveTreeIterator_methods[] = { static zend_class_entry *register_class_EmptyIterator(zend_class_entry *class_entry_Iterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "EmptyIterator", class_EmptyIterator_methods); + INIT_CLASS_NAME(namespaced_name, "EmptyIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_EmptyIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_Iterator); @@ -614,8 +616,10 @@ static zend_class_entry *register_class_EmptyIterator(zend_class_entry *class_en static zend_class_entry *register_class_CallbackFilterIterator(zend_class_entry *class_entry_FilterIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "CallbackFilterIterator", class_CallbackFilterIterator_methods); + INIT_CLASS_NAME(namespaced_name, "CallbackFilterIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_CallbackFilterIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_FilterIterator, 0); return class_entry; @@ -624,8 +628,10 @@ static zend_class_entry *register_class_CallbackFilterIterator(zend_class_entry static zend_class_entry *register_class_RecursiveCallbackFilterIterator(zend_class_entry *class_entry_CallbackFilterIterator, zend_class_entry *class_entry_RecursiveIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RecursiveCallbackFilterIterator", class_RecursiveCallbackFilterIterator_methods); + INIT_CLASS_NAME(namespaced_name, "RecursiveCallbackFilterIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_RecursiveCallbackFilterIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_CallbackFilterIterator, 0); zend_class_implements(class_entry, 1, class_entry_RecursiveIterator); @@ -635,8 +641,10 @@ static zend_class_entry *register_class_RecursiveCallbackFilterIterator(zend_cla static zend_class_entry *register_class_RecursiveIterator(zend_class_entry *class_entry_Iterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RecursiveIterator", class_RecursiveIterator_methods); + INIT_CLASS_NAME(namespaced_name, "RecursiveIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_RecursiveIterator_methods); class_entry = zend_register_internal_interface(&ce); zend_class_implements(class_entry, 1, class_entry_Iterator); @@ -646,8 +654,10 @@ static zend_class_entry *register_class_RecursiveIterator(zend_class_entry *clas static zend_class_entry *register_class_RecursiveIteratorIterator(zend_class_entry *class_entry_OuterIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RecursiveIteratorIterator", class_RecursiveIteratorIterator_methods); + INIT_CLASS_NAME(namespaced_name, "RecursiveIteratorIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_RecursiveIteratorIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_OuterIterator); @@ -681,8 +691,10 @@ static zend_class_entry *register_class_RecursiveIteratorIterator(zend_class_ent static zend_class_entry *register_class_OuterIterator(zend_class_entry *class_entry_Iterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "OuterIterator", class_OuterIterator_methods); + INIT_CLASS_NAME(namespaced_name, "OuterIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_OuterIterator_methods); class_entry = zend_register_internal_interface(&ce); zend_class_implements(class_entry, 1, class_entry_Iterator); @@ -692,8 +704,10 @@ static zend_class_entry *register_class_OuterIterator(zend_class_entry *class_en static zend_class_entry *register_class_IteratorIterator(zend_class_entry *class_entry_OuterIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "IteratorIterator", class_IteratorIterator_methods); + INIT_CLASS_NAME(namespaced_name, "IteratorIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_IteratorIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_OuterIterator); @@ -703,8 +717,10 @@ static zend_class_entry *register_class_IteratorIterator(zend_class_entry *class static zend_class_entry *register_class_FilterIterator(zend_class_entry *class_entry_IteratorIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "FilterIterator", class_FilterIterator_methods); + INIT_CLASS_NAME(namespaced_name, "FilterIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_FilterIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_IteratorIterator, ZEND_ACC_ABSTRACT); return class_entry; @@ -713,8 +729,10 @@ static zend_class_entry *register_class_FilterIterator(zend_class_entry *class_e static zend_class_entry *register_class_RecursiveFilterIterator(zend_class_entry *class_entry_FilterIterator, zend_class_entry *class_entry_RecursiveIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RecursiveFilterIterator", class_RecursiveFilterIterator_methods); + INIT_CLASS_NAME(namespaced_name, "RecursiveFilterIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_RecursiveFilterIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_FilterIterator, ZEND_ACC_ABSTRACT); zend_class_implements(class_entry, 1, class_entry_RecursiveIterator); @@ -724,8 +742,10 @@ static zend_class_entry *register_class_RecursiveFilterIterator(zend_class_entry static zend_class_entry *register_class_ParentIterator(zend_class_entry *class_entry_RecursiveFilterIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ParentIterator", class_ParentIterator_methods); + INIT_CLASS_NAME(namespaced_name, "ParentIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ParentIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RecursiveFilterIterator, 0); return class_entry; @@ -734,8 +754,10 @@ static zend_class_entry *register_class_ParentIterator(zend_class_entry *class_e static zend_class_entry *register_class_SeekableIterator(zend_class_entry *class_entry_Iterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SeekableIterator", class_SeekableIterator_methods); + INIT_CLASS_NAME(namespaced_name, "SeekableIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SeekableIterator_methods); class_entry = zend_register_internal_interface(&ce); zend_class_implements(class_entry, 1, class_entry_Iterator); @@ -745,8 +767,10 @@ static zend_class_entry *register_class_SeekableIterator(zend_class_entry *class static zend_class_entry *register_class_LimitIterator(zend_class_entry *class_entry_IteratorIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "LimitIterator", class_LimitIterator_methods); + INIT_CLASS_NAME(namespaced_name, "LimitIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_LimitIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_IteratorIterator, 0); return class_entry; @@ -755,8 +779,10 @@ static zend_class_entry *register_class_LimitIterator(zend_class_entry *class_en static zend_class_entry *register_class_CachingIterator(zend_class_entry *class_entry_IteratorIterator, zend_class_entry *class_entry_ArrayAccess, zend_class_entry *class_entry_Countable, zend_class_entry *class_entry_Stringable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "CachingIterator", class_CachingIterator_methods); + INIT_CLASS_NAME(namespaced_name, "CachingIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_CachingIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_IteratorIterator, 0); zend_class_implements(class_entry, 3, class_entry_ArrayAccess, class_entry_Countable, class_entry_Stringable); @@ -802,8 +828,10 @@ static zend_class_entry *register_class_CachingIterator(zend_class_entry *class_ static zend_class_entry *register_class_RecursiveCachingIterator(zend_class_entry *class_entry_CachingIterator, zend_class_entry *class_entry_RecursiveIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RecursiveCachingIterator", class_RecursiveCachingIterator_methods); + INIT_CLASS_NAME(namespaced_name, "RecursiveCachingIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_RecursiveCachingIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_CachingIterator, 0); zend_class_implements(class_entry, 1, class_entry_RecursiveIterator); @@ -813,8 +841,10 @@ static zend_class_entry *register_class_RecursiveCachingIterator(zend_class_entr static zend_class_entry *register_class_NoRewindIterator(zend_class_entry *class_entry_IteratorIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "NoRewindIterator", class_NoRewindIterator_methods); + INIT_CLASS_NAME(namespaced_name, "NoRewindIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_NoRewindIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_IteratorIterator, 0); return class_entry; @@ -823,8 +853,10 @@ static zend_class_entry *register_class_NoRewindIterator(zend_class_entry *class static zend_class_entry *register_class_AppendIterator(zend_class_entry *class_entry_IteratorIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "AppendIterator", class_AppendIterator_methods); + INIT_CLASS_NAME(namespaced_name, "AppendIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_AppendIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_IteratorIterator, 0); return class_entry; @@ -833,8 +865,10 @@ static zend_class_entry *register_class_AppendIterator(zend_class_entry *class_e static zend_class_entry *register_class_InfiniteIterator(zend_class_entry *class_entry_IteratorIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "InfiniteIterator", class_InfiniteIterator_methods); + INIT_CLASS_NAME(namespaced_name, "InfiniteIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_InfiniteIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_IteratorIterator, 0); return class_entry; @@ -843,8 +877,10 @@ static zend_class_entry *register_class_InfiniteIterator(zend_class_entry *class static zend_class_entry *register_class_RegexIterator(zend_class_entry *class_entry_FilterIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RegexIterator", class_RegexIterator_methods); + INIT_CLASS_NAME(namespaced_name, "RegexIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_RegexIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_FilterIterator, 0); zval const_USE_KEY_value; @@ -901,8 +937,10 @@ static zend_class_entry *register_class_RegexIterator(zend_class_entry *class_en static zend_class_entry *register_class_RecursiveRegexIterator(zend_class_entry *class_entry_RegexIterator, zend_class_entry *class_entry_RecursiveIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RecursiveRegexIterator", class_RecursiveRegexIterator_methods); + INIT_CLASS_NAME(namespaced_name, "RecursiveRegexIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_RecursiveRegexIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RegexIterator, 0); zend_class_implements(class_entry, 1, class_entry_RecursiveIterator); @@ -912,8 +950,10 @@ static zend_class_entry *register_class_RecursiveRegexIterator(zend_class_entry static zend_class_entry *register_class_RecursiveTreeIterator(zend_class_entry *class_entry_RecursiveIteratorIterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "RecursiveTreeIterator", class_RecursiveTreeIterator_methods); + INIT_CLASS_NAME(namespaced_name, "RecursiveTreeIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_RecursiveTreeIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_RecursiveIteratorIterator, 0); zval const_BYPASS_CURRENT_value; diff --git a/ext/spl/spl_observer.c b/ext/spl/spl_observer.c index af9c598f08b08..1e5f9ed078dd0 100644 --- a/ext/spl/spl_observer.c +++ b/ext/spl/spl_observer.c @@ -91,7 +91,7 @@ static zend_result spl_object_storage_get_hash(zend_hash_key *key, spl_SplObject /* TODO PHP 9: Remove this as this will be enforced from the return type */ if (UNEXPECTED(Z_TYPE(rv) != IS_STRING)) { zend_type_error("%s::getHash(): Return value must be of type string, %s returned", - ZSTR_VAL(intern->std.ce->name), zend_zval_value_name(&rv)); + ZSTR_VAL(intern->std.ce->namespaced_name.name), zend_zval_value_name(&rv)); zval_ptr_dtor(&rv); return FAILURE; } else { diff --git a/ext/spl/spl_observer_arginfo.h b/ext/spl/spl_observer_arginfo.h index be12c594e0146..a3f19939ec6a0 100644 --- a/ext/spl/spl_observer_arginfo.h +++ b/ext/spl/spl_observer_arginfo.h @@ -233,8 +233,10 @@ static const zend_function_entry class_MultipleIterator_methods[] = { static zend_class_entry *register_class_SplObserver(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplObserver", class_SplObserver_methods); + INIT_CLASS_NAME(namespaced_name, "SplObserver"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplObserver_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -243,8 +245,10 @@ static zend_class_entry *register_class_SplObserver(void) static zend_class_entry *register_class_SplSubject(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplSubject", class_SplSubject_methods); + INIT_CLASS_NAME(namespaced_name, "SplSubject"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplSubject_methods); class_entry = zend_register_internal_interface(&ce); return class_entry; @@ -253,8 +257,10 @@ static zend_class_entry *register_class_SplSubject(void) static zend_class_entry *register_class_SplObjectStorage(zend_class_entry *class_entry_Countable, zend_class_entry *class_entry_SeekableIterator, zend_class_entry *class_entry_Serializable, zend_class_entry *class_entry_ArrayAccess) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SplObjectStorage", class_SplObjectStorage_methods); + INIT_CLASS_NAME(namespaced_name, "SplObjectStorage"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SplObjectStorage_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 4, class_entry_Countable, class_entry_SeekableIterator, class_entry_Serializable, class_entry_ArrayAccess); @@ -264,8 +270,10 @@ static zend_class_entry *register_class_SplObjectStorage(zend_class_entry *class static zend_class_entry *register_class_MultipleIterator(zend_class_entry *class_entry_Iterator) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "MultipleIterator", class_MultipleIterator_methods); + INIT_CLASS_NAME(namespaced_name, "MultipleIterator"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_MultipleIterator_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_Iterator); diff --git a/ext/sqlite3/sqlite3_arginfo.h b/ext/sqlite3/sqlite3_arginfo.h index 654e25edead6c..06cc9547a1b2b 100644 --- a/ext/sqlite3/sqlite3_arginfo.h +++ b/ext/sqlite3/sqlite3_arginfo.h @@ -288,8 +288,10 @@ static void register_sqlite3_symbols(int module_number) static zend_class_entry *register_class_SQLite3Exception(zend_class_entry *class_entry_Exception) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SQLite3Exception", NULL); + INIT_CLASS_NAME(namespaced_name, "SQLite3Exception"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Exception, ZEND_ACC_NO_DYNAMIC_PROPERTIES); return class_entry; @@ -298,8 +300,10 @@ static zend_class_entry *register_class_SQLite3Exception(zend_class_entry *class static zend_class_entry *register_class_SQLite3(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SQLite3", class_SQLite3_methods); + INIT_CLASS_NAME(namespaced_name, "SQLite3"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SQLite3_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); zval const_OK_value; @@ -532,8 +536,10 @@ static zend_class_entry *register_class_SQLite3(void) static zend_class_entry *register_class_SQLite3Stmt(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SQLite3Stmt", class_SQLite3Stmt_methods); + INIT_CLASS_NAME(namespaced_name, "SQLite3Stmt"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SQLite3Stmt_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -542,8 +548,10 @@ static zend_class_entry *register_class_SQLite3Stmt(void) static zend_class_entry *register_class_SQLite3Result(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SQLite3Result", class_SQLite3Result_methods); + INIT_CLASS_NAME(namespaced_name, "SQLite3Result"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_SQLite3Result_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/standard/basic_functions_arginfo.h b/ext/standard/basic_functions_arginfo.h index 3d92288643159..dbc8f54f4f0f6 100644 --- a/ext/standard/basic_functions_arginfo.h +++ b/ext/standard/basic_functions_arginfo.h @@ -4047,8 +4047,10 @@ static void register_basic_functions_symbols(int module_number) static zend_class_entry *register_class___PHP_Incomplete_Class(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "__PHP_Incomplete_Class", NULL); + INIT_CLASS_NAME(namespaced_name, "__PHP_Incomplete_Class"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES); zend_string *attribute_name_AllowDynamicProperties_class___PHP_Incomplete_Class_0 = zend_string_init_interned("AllowDynamicProperties", sizeof("AllowDynamicProperties") - 1, 1); @@ -4061,8 +4063,10 @@ static zend_class_entry *register_class___PHP_Incomplete_Class(void) static zend_class_entry *register_class_AssertionError(zend_class_entry *class_entry_Error) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "AssertionError", NULL); + INIT_CLASS_NAME(namespaced_name, "AssertionError"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, class_entry_Error, 0); return class_entry; diff --git a/ext/standard/dir_arginfo.h b/ext/standard/dir_arginfo.h index 9b293f3cd753f..775cc2a9c1650 100644 --- a/ext/standard/dir_arginfo.h +++ b/ext/standard/dir_arginfo.h @@ -56,8 +56,10 @@ static void register_dir_symbols(int module_number) static zend_class_entry *register_class_Directory(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "Directory", class_Directory_methods); + INIT_CLASS_NAME(namespaced_name, "Directory"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_Directory_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); zval property_path_default_value; diff --git a/ext/standard/http.c b/ext/standard/http.c index fd862b605a7e6..5f3d5f278b190 100644 --- a/ext/standard/http.c +++ b/ext/standard/http.c @@ -95,7 +95,7 @@ static void php_url_encode_scalar(zval *scalar, smart_str *form_str, case IS_OBJECT: ZEND_ASSERT(Z_OBJCE_P(scalar)->ce_flags & ZEND_ACC_ENUM); if (Z_OBJCE_P(scalar)->enum_backing_type == IS_UNDEF) { - zend_value_error("Unbacked enum %s cannot be converted to a string", ZSTR_VAL(Z_OBJCE_P(scalar)->name)); + zend_value_error("Unbacked enum %s cannot be converted to a string", ZSTR_VAL(Z_OBJCE_P(scalar)->namespaced_name.name)); return; } scalar = zend_enum_fetch_case_value(Z_OBJ_P(scalar)); diff --git a/ext/standard/php_incomplete_class.h b/ext/standard/php_incomplete_class.h index 07eabf60d5dc9..4bae34dec7f7a 100644 --- a/ext/standard/php_incomplete_class.h +++ b/ext/standard/php_incomplete_class.h @@ -32,7 +32,7 @@ extern PHPAPI zend_class_entry *php_ce_incomplete_class; } \ incomplete_class = 1; \ } else { \ - class_name = zend_string_copy(Z_OBJCE_P(struc)->name); \ + class_name = zend_string_copy(Z_OBJCE_P(struc)->namespaced_name.name); \ } #define PHP_CLEANUP_CLASS_ATTRIBUTES() \ diff --git a/ext/standard/type.c b/ext/standard/type.c index 4557014ff5a33..3307257936a87 100644 --- a/ext/standard/type.c +++ b/ext/standard/type.c @@ -61,10 +61,10 @@ PHP_FUNCTION(get_debug_type) RETURN_INTERNED_STR(ZSTR_KNOWN(ZEND_STR_ARRAY)); case IS_OBJECT: if (Z_OBJ_P(arg)->ce->ce_flags & ZEND_ACC_ANON_CLASS) { - name = ZSTR_VAL(Z_OBJ_P(arg)->ce->name); + name = ZSTR_VAL(Z_OBJ_P(arg)->ce->namespaced_name.name); RETURN_NEW_STR(zend_string_init(name, strlen(name), 0)); } else { - RETURN_STR_COPY(Z_OBJ_P(arg)->ce->name); + RETURN_STR_COPY(Z_OBJ_P(arg)->ce->namespaced_name.name); } case IS_RESOURCE: name = zend_rsrc_list_get_rsrc_type(Z_RES_P(arg)); diff --git a/ext/standard/user_filters_arginfo.h b/ext/standard/user_filters_arginfo.h index 0411355b71222..51f132b91bc61 100644 --- a/ext/standard/user_filters_arginfo.h +++ b/ext/standard/user_filters_arginfo.h @@ -38,8 +38,10 @@ static void register_user_filters_symbols(int module_number) static zend_class_entry *register_class_php_user_filter(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "php_user_filter", class_php_user_filter_methods); + INIT_CLASS_NAME(namespaced_name, "php_user_filter"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_php_user_filter_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_filtername_default_value; @@ -66,8 +68,10 @@ static zend_class_entry *register_class_php_user_filter(void) static zend_class_entry *register_class_StreamBucket(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "StreamBucket", NULL); + INIT_CLASS_NAME(namespaced_name, "StreamBucket"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zval property_bucket_default_value; diff --git a/ext/standard/var.c b/ext/standard/var.c index 1c2b0eb164a1c..9ab648ff5c598 100644 --- a/ext/standard/var.c +++ b/ext/standard/var.c @@ -164,7 +164,7 @@ PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */ zend_class_entry *ce = Z_OBJCE_P(struc); if (ce->ce_flags & ZEND_ACC_ENUM) { zval *case_name_zval = zend_enum_fetch_case_name(Z_OBJ_P(struc)); - php_printf("%senum(%s::%s)\n", COMMON, ZSTR_VAL(ce->name), Z_STRVAL_P(case_name_zval)); + php_printf("%senum(%s::%s)\n", COMMON, ZSTR_VAL(ce->namespaced_name.name), Z_STRVAL_P(case_name_zval)); return; } zend_object *zobj = Z_OBJ_P(struc); @@ -614,7 +614,7 @@ PHPAPI zend_result php_var_export_ex(zval *struc, int level, smart_str *buf) /* smart_str_appendl(buf, "(object) array(\n", 16); } else { smart_str_appendc(buf, '\\'); - smart_str_append(buf, ce->name); + smart_str_append(buf, ce->namespaced_name.name); if (is_enum) { zend_object *zobj = Z_OBJ_P(struc); zval *case_name_zval = zend_enum_fetch_case_name(zobj); @@ -836,7 +836,7 @@ static HashTable* php_var_serialize_call_sleep(zend_object *obj, zend_function * if (Z_TYPE(retval) != IS_ARRAY) { zval_ptr_dtor(&retval); - php_error_docref(NULL, E_WARNING, "%s::__sleep() should return an array only containing the names of instance-variables to serialize", ZSTR_VAL(obj->ce->name)); + php_error_docref(NULL, E_WARNING, "%s::__sleep() should return an array only containing the names of instance-variables to serialize", ZSTR_VAL(obj->ce->namespaced_name.name)); return NULL; } @@ -858,7 +858,7 @@ static int php_var_serialize_call_magic_serialize(zval *retval, zval *obj) /* {{ if (Z_TYPE_P(retval) != IS_ARRAY) { zval_ptr_dtor(retval); - zend_type_error("%s::__serialize() must return an array", ZSTR_VAL(Z_OBJCE_P(obj)->name)); + zend_type_error("%s::__serialize() must return an array", ZSTR_VAL(Z_OBJCE_P(obj)->namespaced_name.name)); return FAILURE; } @@ -914,7 +914,7 @@ static int php_var_serialize_get_sleep_props( if (Z_TYPE_P(name_val) != IS_STRING) { php_error_docref(NULL, E_WARNING, "%s::__sleep() should return an array only containing the names of instance-variables to serialize", - ZSTR_VAL(ce->name)); + ZSTR_VAL(ce->namespaced_name.name)); } name = zval_get_tmp_string(name_val, &tmp_name); @@ -930,7 +930,7 @@ static int php_var_serialize_get_sleep_props( } priv_name = zend_mangle_property_name( - ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), + ZSTR_VAL(ce->namespaced_name.name), ZSTR_LEN(ce->namespaced_name.name), ZSTR_VAL(name), ZSTR_LEN(name), ce->type & ZEND_INTERNAL_CLASS); if (php_var_serialize_try_add_sleep_prop(ht, props, priv_name, name, struc) == SUCCESS) { zend_tmp_string_release(tmp_name); @@ -1116,7 +1116,7 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, php_serialize_ if (ce->ce_flags & ZEND_ACC_NOT_SERIALIZABLE) { zend_throw_exception_ex(NULL, 0, "Serialization of '%s' is not allowed", - ZSTR_VAL(ce->name)); + ZSTR_VAL(ce->namespaced_name.name)); return; } @@ -1181,15 +1181,15 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, php_serialize_ if (ce->serialize(struc, &serialized_data, &serialized_length, (zend_serialize_data *)var_hash) == SUCCESS) { char b1[32], b2[32]; - char *s1 = zend_print_long_to_buf(b1 + sizeof(b1) - 1, ZSTR_LEN(Z_OBJCE_P(struc)->name)); + char *s1 = zend_print_long_to_buf(b1 + sizeof(b1) - 1, ZSTR_LEN(Z_OBJCE_P(struc)->namespaced_name.name)); size_t l1 = b1 + sizeof(b1) - 1 - s1; char *s2 = zend_print_long_to_buf(b2 + sizeof(b2) - 1, serialized_length); size_t l2 = b2 + sizeof(b2) - 1 - s2; - char *res = smart_str_extend(buf, 2 + l1 + 2 + ZSTR_LEN(Z_OBJCE_P(struc)->name) + 2 + l2 + 2 + serialized_length + 1); + char *res = smart_str_extend(buf, 2 + l1 + 2 + ZSTR_LEN(Z_OBJCE_P(struc)->namespaced_name.name) + 2 + l2 + 2 + serialized_length + 1); res = zend_mempcpy(res, "C:", 2); res = zend_mempcpy(res, s1, l1); res = zend_mempcpy(res, ":\"", 2); - res = zend_mempcpy(res, ZSTR_VAL(Z_OBJCE_P(struc)->name), ZSTR_LEN(Z_OBJCE_P(struc)->name)); + res = zend_mempcpy(res, ZSTR_VAL(Z_OBJCE_P(struc)->namespaced_name.name), ZSTR_LEN(Z_OBJCE_P(struc)->namespaced_name.name)); res = zend_mempcpy(res, "\":", 2); res = zend_mempcpy(res, s2, l2); res = zend_mempcpy(res, ":{", 2); diff --git a/ext/standard/var_unserializer.re b/ext/standard/var_unserializer.re index cbd457e16fdb1..146861eb74eca 100644 --- a/ext/standard/var_unserializer.re +++ b/ext/standard/var_unserializer.re @@ -548,7 +548,7 @@ static int is_property_visibility_changed(zend_class_entry *ce, zval *key) existing_propinfo = zend_hash_find_ptr(&ce->properties_info, Z_STR_P(key)); } else { if (!strcmp(unmangled_class, "*") - || !strcasecmp(unmangled_class, ZSTR_VAL(ce->name))) { + || !strcasecmp(unmangled_class, ZSTR_VAL(ce->namespaced_name.name))) { existing_propinfo = zend_hash_str_find_ptr( &ce->properties_info, unmangled_prop, unmangled_prop_len); } @@ -562,7 +562,7 @@ static int is_property_visibility_changed(zend_class_entry *ce, zval *key) } else { php_error_docref(NULL, E_WARNING, "Cannot unserialize value for virtual property %s::$%s", - ZSTR_VAL(existing_propinfo->ce->name), Z_STRVAL_P(key)); + ZSTR_VAL(existing_propinfo->ce->namespaced_name.name), Z_STRVAL_P(key)); zval_ptr_dtor_str(key); return -1; } @@ -642,12 +642,12 @@ declared_property: if (EXPECTED(!ret)) { if (UNEXPECTED(obj->ce->ce_flags & ZEND_ACC_NO_DYNAMIC_PROPERTIES)) { zend_throw_error(NULL, "Cannot create dynamic property %s::$%s", - ZSTR_VAL(obj->ce->name), zend_get_unmangled_property_name(Z_STR_P(&key))); + ZSTR_VAL(obj->ce->namespaced_name.name), zend_get_unmangled_property_name(Z_STR_P(&key))); zval_ptr_dtor_str(&key); goto failure; } else if (!(obj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { zend_error(E_DEPRECATED, "Creation of dynamic property %s::$%s is deprecated", - ZSTR_VAL(obj->ce->name), zend_get_unmangled_property_name(Z_STR_P(&key))); + ZSTR_VAL(obj->ce->namespaced_name.name), zend_get_unmangled_property_name(Z_STR_P(&key))); if (EG(exception)) { zval_ptr_dtor_str(&key); goto failure; @@ -771,7 +771,7 @@ static inline int object_custom(UNSERIALIZE_PARAMETER, zend_class_entry *ce) } if (ce->unserialize == NULL) { - zend_error(E_WARNING, "Class %s has no unserializer", ZSTR_VAL(ce->name)); + zend_error(E_WARNING, "Class %s has no unserializer", ZSTR_VAL(ce->namespaced_name.name)); object_init_ex(rval, ce); } else if (ce->unserialize(rval, ce, (const unsigned char*)*p, datalen, (zend_unserialize_data *)var_hash) != SUCCESS) { return 0; @@ -1280,7 +1280,7 @@ object ":" uiv ":" ["] { if (ce->ce_flags & ZEND_ACC_NOT_SERIALIZABLE) { zend_throw_exception_ex(NULL, 0, "Unserialization of '%s' is not allowed", - ZSTR_VAL(ce->name)); + ZSTR_VAL(ce->namespaced_name.name)); zend_string_release_ex(class_name, 0); return 0; } @@ -1328,7 +1328,7 @@ object ":" uiv ":" ["] { * there is both Serializable::unserialize() and __unserialize(), then both may be used, * depending on the serialization format. */ if (ce->serialize != NULL && !has_unserialize) { - zend_error(E_WARNING, "Erroneous data format for unserializing '%s'", ZSTR_VAL(ce->name)); + zend_error(E_WARNING, "Erroneous data format for unserializing '%s'", ZSTR_VAL(ce->namespaced_name.name)); zend_string_release_ex(class_name, 0); return 0; } diff --git a/ext/sysvmsg/sysvmsg_arginfo.h b/ext/sysvmsg/sysvmsg_arginfo.h index 26f81c0295be0..e80e464283abd 100644 --- a/ext/sysvmsg/sysvmsg_arginfo.h +++ b/ext/sysvmsg/sysvmsg_arginfo.h @@ -74,8 +74,10 @@ static void register_sysvmsg_symbols(int module_number) static zend_class_entry *register_class_SysvMessageQueue(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SysvMessageQueue", NULL); + INIT_CLASS_NAME(namespaced_name, "SysvMessageQueue"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/sysvsem/sysvsem_arginfo.h b/ext/sysvsem/sysvsem_arginfo.h index 55bca0539fdde..aa9e1ccf4c5c2 100644 --- a/ext/sysvsem/sysvsem_arginfo.h +++ b/ext/sysvsem/sysvsem_arginfo.h @@ -35,8 +35,10 @@ static const zend_function_entry ext_functions[] = { static zend_class_entry *register_class_SysvSemaphore(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SysvSemaphore", NULL); + INIT_CLASS_NAME(namespaced_name, "SysvSemaphore"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/sysvshm/sysvshm_arginfo.h b/ext/sysvshm/sysvshm_arginfo.h index bca40b0e0944d..6c5a7d004dcde 100644 --- a/ext/sysvshm/sysvshm_arginfo.h +++ b/ext/sysvshm/sysvshm_arginfo.h @@ -53,8 +53,10 @@ static const zend_function_entry ext_functions[] = { static zend_class_entry *register_class_SysvSharedMemory(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "SysvSharedMemory", NULL); + INIT_CLASS_NAME(namespaced_name, "SysvSharedMemory"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/tidy/tidy_arginfo.h b/ext/tidy/tidy_arginfo.h index b7dae788ef316..0dd3119474d76 100644 --- a/ext/tidy/tidy_arginfo.h +++ b/ext/tidy/tidy_arginfo.h @@ -524,8 +524,10 @@ static void register_tidy_symbols(int module_number) static zend_class_entry *register_class_tidy(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "tidy", class_tidy_methods); + INIT_CLASS_NAME(namespaced_name, "tidy"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_tidy_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_errorBuffer_default_value; @@ -544,8 +546,10 @@ static zend_class_entry *register_class_tidy(void) static zend_class_entry *register_class_tidyNode(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "tidyNode", class_tidyNode_methods); + INIT_CLASS_NAME(namespaced_name, "tidyNode"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_tidyNode_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zval property_value_default_value; diff --git a/ext/tokenizer/tokenizer.c b/ext/tokenizer/tokenizer.c index 9d1b19df91163..051d6dfbe0452 100644 --- a/ext/tokenizer/tokenizer.c +++ b/ext/tokenizer/tokenizer.c @@ -103,7 +103,7 @@ PHP_METHOD(PhpToken, tokenize) /* Check construction preconditions in advance, so these are not repeated for each token. */ if (token_class->ce_flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS) { - zend_throw_error(NULL, "Cannot instantiate abstract class %s", ZSTR_VAL(token_class->name)); + zend_throw_error(NULL, "Cannot instantiate abstract class %s", ZSTR_VAL(token_class->namespaced_name.name)); RETURN_THROWS(); } if (zend_update_class_constants(token_class) == FAILURE) { diff --git a/ext/tokenizer/tokenizer_arginfo.h b/ext/tokenizer/tokenizer_arginfo.h index b98a5655b6c74..ebfcd3dfc0016 100644 --- a/ext/tokenizer/tokenizer_arginfo.h +++ b/ext/tokenizer/tokenizer_arginfo.h @@ -65,8 +65,10 @@ static void register_tokenizer_symbols(int module_number) static zend_class_entry *register_class_PhpToken(zend_class_entry *class_entry_Stringable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "PhpToken", class_PhpToken_methods); + INIT_CLASS_NAME(namespaced_name, "PhpToken"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_PhpToken_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_Stringable); diff --git a/ext/xml/xml.c b/ext/xml/xml.c index bf9f747599730..e11a84142798f 100644 --- a/ext/xml/xml.c +++ b/ext/xml/xml.c @@ -1173,7 +1173,7 @@ static bool php_xml_check_string_method_arg( zend_function *method_ptr = zend_hash_find_ptr_lc(&ce->function_table, method_name); if (!method_ptr) { if (arg_num) { - zend_argument_value_error(arg_num, "method %s::%s() does not exist", ZSTR_VAL(ce->name), ZSTR_VAL(method_name)); + zend_argument_value_error(arg_num, "method %s::%s() does not exist", ZSTR_VAL(ce->namespaced_name.name), ZSTR_VAL(method_name)); } return false; } @@ -1198,7 +1198,7 @@ static bool php_xml_check_string_method_arg( bool status = php_xml_check_string_method_arg(0, new_this_obj, method_name, &parser_to_check->fcc_field); \ if (status == false) { \ zend_argument_value_error(2, "cannot safely swap to object of class %s as method \"%s\" does not exist, which was set via " handler_set_method, \ - ZSTR_VAL(new_this_obj->ce->name), ZSTR_VAL(method_name)); \ + ZSTR_VAL(new_this_obj->ce->namespaced_name.name), ZSTR_VAL(method_name)); \ zend_string_release(method_name); \ RETURN_THROWS(); \ } \ diff --git a/ext/xml/xml_arginfo.h b/ext/xml/xml_arginfo.h index a432059a3f14e..22661088f2870 100644 --- a/ext/xml/xml_arginfo.h +++ b/ext/xml/xml_arginfo.h @@ -179,8 +179,10 @@ static void register_xml_symbols(int module_number) static zend_class_entry *register_class_XMLParser(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "XMLParser", NULL); + INIT_CLASS_NAME(namespaced_name, "XMLParser"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/ext/xmlreader/php_xmlreader.c b/ext/xmlreader/php_xmlreader.c index 9bc0af63a791e..391aeadfd4859 100644 --- a/ext/xmlreader/php_xmlreader.c +++ b/ext/xmlreader/php_xmlreader.c @@ -201,7 +201,7 @@ static zval *xmlreader_write_property(zend_object *object, zend_string *name, zv xmlreader_prop_handler *hnd = xmlreader_get_prop_handler(name, cache_slot); if (hnd != NULL) { - zend_readonly_property_modification_error_ex(ZSTR_VAL(object->ce->name), ZSTR_VAL(name)); + zend_readonly_property_modification_error_ex(ZSTR_VAL(object->ce->namespaced_name.name), ZSTR_VAL(name)); } else { value = zend_std_write_property(object, name, value, cache_slot); } @@ -215,7 +215,7 @@ void xmlreader_unset_property(zend_object *object, zend_string *name, void **cac xmlreader_prop_handler *hnd = xmlreader_get_prop_handler(name, cache_slot); if (hnd != NULL) { - zend_throw_error(NULL, "Cannot unset %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(name)); + zend_throw_error(NULL, "Cannot unset %s::$%s", ZSTR_VAL(object->ce->namespaced_name.name), ZSTR_VAL(name)); return; } @@ -1299,7 +1299,7 @@ PHP_METHOD(XMLReader, expand) /* Note: cannot use NODE_GET_OBJ here because of the wrong return type */ domobj = Z_LIBXML_NODE_P(basenode); if (UNEXPECTED(domobj->node == NULL)) { - php_error_docref(NULL, E_WARNING, "Couldn't fetch %s", ZSTR_VAL(Z_OBJCE_P(basenode)->name)); + php_error_docref(NULL, E_WARNING, "Couldn't fetch %s", ZSTR_VAL(Z_OBJCE_P(basenode)->namespaced_name.name)); RETURN_FALSE; } node = domobj->node->node; diff --git a/ext/xmlreader/php_xmlreader_arginfo.h b/ext/xmlreader/php_xmlreader_arginfo.h index dd5ca550f606d..88d56abdba1b4 100644 --- a/ext/xmlreader/php_xmlreader_arginfo.h +++ b/ext/xmlreader/php_xmlreader_arginfo.h @@ -174,8 +174,10 @@ static const zend_function_entry class_XMLReader_methods[] = { static zend_class_entry *register_class_XMLReader(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "XMLReader", class_XMLReader_methods); + INIT_CLASS_NAME(namespaced_name, "XMLReader"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_XMLReader_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval const_NONE_value; diff --git a/ext/xmlwriter/php_xmlwriter_arginfo.h b/ext/xmlwriter/php_xmlwriter_arginfo.h index ebccf4225ba9f..989e332d3772d 100644 --- a/ext/xmlwriter/php_xmlwriter_arginfo.h +++ b/ext/xmlwriter/php_xmlwriter_arginfo.h @@ -482,8 +482,10 @@ static const zend_function_entry class_XMLWriter_methods[] = { static zend_class_entry *register_class_XMLWriter(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "XMLWriter", class_XMLWriter_methods); + INIT_CLASS_NAME(namespaced_name, "XMLWriter"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_XMLWriter_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); return class_entry; diff --git a/ext/xsl/php_xsl_arginfo.h b/ext/xsl/php_xsl_arginfo.h index d040928197f65..2a57eaa4d1b44 100644 --- a/ext/xsl/php_xsl_arginfo.h +++ b/ext/xsl/php_xsl_arginfo.h @@ -115,8 +115,10 @@ static void register_php_xsl_symbols(int module_number) static zend_class_entry *register_class_XSLTProcessor(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "XSLTProcessor", class_XSLTProcessor_methods); + INIT_CLASS_NAME(namespaced_name, "XSLTProcessor"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_XSLTProcessor_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_doXInclude_default_value; diff --git a/ext/zend_test/fiber_arginfo.h b/ext/zend_test/fiber_arginfo.h index e4a0b51bebc9d..42fd39ae49ca8 100644 --- a/ext/zend_test/fiber_arginfo.h +++ b/ext/zend_test/fiber_arginfo.h @@ -37,8 +37,10 @@ static const zend_function_entry class__ZendTestFiber_methods[] = { static zend_class_entry *register_class__ZendTestFiber(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "_ZendTestFiber", class__ZendTestFiber_methods); + INIT_CLASS_NAME(namespaced_name, "_ZendTestFiber"); + INIT_CLASS_ENTRY(ce, namespaced_name, class__ZendTestFiber_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); return class_entry; diff --git a/ext/zend_test/iterators_arginfo.h b/ext/zend_test/iterators_arginfo.h index 3ec78808eaa19..b41760ecb3cbd 100644 --- a/ext/zend_test/iterators_arginfo.h +++ b/ext/zend_test/iterators_arginfo.h @@ -19,8 +19,10 @@ static const zend_function_entry class_ZendTest_Iterators_TraversableTest_method static zend_class_entry *register_class_ZendTest_Iterators_TraversableTest(zend_class_entry *class_entry_IteratorAggregate) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "ZendTest\\Iterators", "TraversableTest", class_ZendTest_Iterators_TraversableTest_methods); + INIT_CLASS_NAME_NS(namespaced_name, "ZendTest\\Iterators", "TraversableTest"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTest_Iterators_TraversableTest_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zend_class_implements(class_entry, 1, class_entry_IteratorAggregate); diff --git a/ext/zend_test/object_handlers_arginfo.h b/ext/zend_test/object_handlers_arginfo.h index 370ad13894aa8..d837c0f037286 100644 --- a/ext/zend_test/object_handlers_arginfo.h +++ b/ext/zend_test/object_handlers_arginfo.h @@ -43,8 +43,10 @@ static const zend_function_entry class_NumericCastableNoOperations_methods[] = { static zend_class_entry *register_class_DoOperationNoCast(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DoOperationNoCast", class_DoOperationNoCast_methods); + INIT_CLASS_NAME(namespaced_name, "DoOperationNoCast"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_DoOperationNoCast_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zval property_val_default_value; @@ -59,8 +61,10 @@ static zend_class_entry *register_class_DoOperationNoCast(void) static zend_class_entry *register_class_LongCastableNoOperations(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "LongCastableNoOperations", class_LongCastableNoOperations_methods); + INIT_CLASS_NAME(namespaced_name, "LongCastableNoOperations"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_LongCastableNoOperations_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zval property_val_default_value; @@ -75,8 +79,10 @@ static zend_class_entry *register_class_LongCastableNoOperations(void) static zend_class_entry *register_class_FloatCastableNoOperations(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "FloatCastableNoOperations", class_FloatCastableNoOperations_methods); + INIT_CLASS_NAME(namespaced_name, "FloatCastableNoOperations"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_FloatCastableNoOperations_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zval property_val_default_value; @@ -91,8 +97,10 @@ static zend_class_entry *register_class_FloatCastableNoOperations(void) static zend_class_entry *register_class_NumericCastableNoOperations(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "NumericCastableNoOperations", class_NumericCastableNoOperations_methods); + INIT_CLASS_NAME(namespaced_name, "NumericCastableNoOperations"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_NumericCastableNoOperations_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); zval property_val_default_value; @@ -107,8 +115,10 @@ static zend_class_entry *register_class_NumericCastableNoOperations(void) static zend_class_entry *register_class_DimensionHandlersNoArrayAccess(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DimensionHandlersNoArrayAccess", NULL); + INIT_CLASS_NAME(namespaced_name, "DimensionHandlersNoArrayAccess"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zval property_read_default_value; diff --git a/ext/zend_test/test_arginfo.h b/ext/zend_test/test_arginfo.h index c558b58f65169..31caa9645a96f 100644 --- a/ext/zend_test/test_arginfo.h +++ b/ext/zend_test/test_arginfo.h @@ -581,8 +581,10 @@ static void register_test_symbols(int module_number) static zend_class_entry *register_class__ZendTestInterface(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "_ZendTestInterface", NULL); + INIT_CLASS_NAME(namespaced_name, "_ZendTestInterface"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_interface(&ce); zval const_DUMMY_value; @@ -598,8 +600,10 @@ static zend_class_entry *register_class__ZendTestInterface(void) static zend_class_entry *register_class__ZendTestClass(zend_class_entry *class_entry__ZendTestInterface) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "_ZendTestClass", class__ZendTestClass_methods); + INIT_CLASS_NAME(namespaced_name, "_ZendTestClass"); + INIT_CLASS_ENTRY(ce, namespaced_name, class__ZendTestClass_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); #else @@ -745,8 +749,10 @@ static zend_class_entry *register_class__ZendTestClass(zend_class_entry *class_e static zend_class_entry *register_class__ZendTestMagicCall(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "_ZendTestMagicCall", class__ZendTestMagicCall_methods); + INIT_CLASS_NAME(namespaced_name, "_ZendTestMagicCall"); + INIT_CLASS_ENTRY(ce, namespaced_name, class__ZendTestMagicCall_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); #else @@ -759,8 +765,10 @@ static zend_class_entry *register_class__ZendTestMagicCall(void) static zend_class_entry *register_class__ZendTestMagicCallForward(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "_ZendTestMagicCallForward", class__ZendTestMagicCallForward_methods); + INIT_CLASS_NAME(namespaced_name, "_ZendTestMagicCallForward"); + INIT_CLASS_ENTRY(ce, namespaced_name, class__ZendTestMagicCallForward_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); #else @@ -773,8 +781,10 @@ static zend_class_entry *register_class__ZendTestMagicCallForward(void) static zend_class_entry *register_class__ZendTestChildClass(zend_class_entry *class_entry__ZendTestClass) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "_ZendTestChildClass", class__ZendTestChildClass_methods); + INIT_CLASS_NAME(namespaced_name, "_ZendTestChildClass"); + INIT_CLASS_ENTRY(ce, namespaced_name, class__ZendTestChildClass_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, class_entry__ZendTestClass, 0); #else @@ -787,8 +797,10 @@ static zend_class_entry *register_class__ZendTestChildClass(zend_class_entry *cl static zend_class_entry *register_class_ZendAttributeTest(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ZendAttributeTest", class_ZendAttributeTest_methods); + INIT_CLASS_NAME(namespaced_name, "ZendAttributeTest"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendAttributeTest_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); #else @@ -840,8 +852,10 @@ static zend_class_entry *register_class_ZendAttributeTest(void) static zend_class_entry *register_class__ZendTestTrait(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "_ZendTestTrait", class__ZendTestTrait_methods); + INIT_CLASS_NAME(namespaced_name, "_ZendTestTrait"); + INIT_CLASS_ENTRY(ce, namespaced_name, class__ZendTestTrait_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_TRAIT); #else @@ -874,8 +888,10 @@ static zend_class_entry *register_class__ZendTestTrait(void) static zend_class_entry *register_class_ZendTestAttribute(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ZendTestAttribute", NULL); + INIT_CLASS_NAME(namespaced_name, "ZendTestAttribute"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); #else @@ -896,8 +912,10 @@ static zend_class_entry *register_class_ZendTestAttribute(void) static zend_class_entry *register_class_ZendTestAttributeWithArguments(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ZendTestAttributeWithArguments", class_ZendTestAttributeWithArguments_methods); + INIT_CLASS_NAME(namespaced_name, "ZendTestAttributeWithArguments"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTestAttributeWithArguments_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); #else @@ -928,8 +946,10 @@ static zend_class_entry *register_class_ZendTestAttributeWithArguments(void) static zend_class_entry *register_class_ZendTestRepeatableAttribute(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ZendTestRepeatableAttribute", NULL); + INIT_CLASS_NAME(namespaced_name, "ZendTestRepeatableAttribute"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); #else @@ -950,8 +970,10 @@ static zend_class_entry *register_class_ZendTestRepeatableAttribute(void) static zend_class_entry *register_class_ZendTestParameterAttribute(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ZendTestParameterAttribute", class_ZendTestParameterAttribute_methods); + INIT_CLASS_NAME(namespaced_name, "ZendTestParameterAttribute"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTestParameterAttribute_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); #else @@ -978,8 +1000,10 @@ static zend_class_entry *register_class_ZendTestParameterAttribute(void) static zend_class_entry *register_class_ZendTestPropertyAttribute(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ZendTestPropertyAttribute", class_ZendTestPropertyAttribute_methods); + INIT_CLASS_NAME(namespaced_name, "ZendTestPropertyAttribute"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTestPropertyAttribute_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); #else @@ -1010,8 +1034,10 @@ static zend_class_entry *register_class_ZendTestPropertyAttribute(void) static zend_class_entry *register_class_ZendTestClassWithMethodWithParameterAttribute(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ZendTestClassWithMethodWithParameterAttribute", class_ZendTestClassWithMethodWithParameterAttribute_methods); + INIT_CLASS_NAME(namespaced_name, "ZendTestClassWithMethodWithParameterAttribute"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTestClassWithMethodWithParameterAttribute_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); #else @@ -1041,8 +1067,10 @@ static zend_class_entry *register_class_ZendTestClassWithMethodWithParameterAttr static zend_class_entry *register_class_ZendTestChildClassWithMethodWithParameterAttribute(zend_class_entry *class_entry_ZendTestClassWithMethodWithParameterAttribute) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ZendTestChildClassWithMethodWithParameterAttribute", class_ZendTestChildClassWithMethodWithParameterAttribute_methods); + INIT_CLASS_NAME(namespaced_name, "ZendTestChildClassWithMethodWithParameterAttribute"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTestChildClassWithMethodWithParameterAttribute_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, class_entry_ZendTestClassWithMethodWithParameterAttribute, 0); #else @@ -1064,8 +1092,10 @@ static zend_class_entry *register_class_ZendTestChildClassWithMethodWithParamete static zend_class_entry *register_class_ZendTestClassWithPropertyAttribute(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ZendTestClassWithPropertyAttribute", NULL); + INIT_CLASS_NAME(namespaced_name, "ZendTestClassWithPropertyAttribute"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); #else @@ -1089,8 +1119,10 @@ static zend_class_entry *register_class_ZendTestClassWithPropertyAttribute(void) static zend_class_entry *register_class_ZendTestForbidDynamicCall(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ZendTestForbidDynamicCall", class_ZendTestForbidDynamicCall_methods); + INIT_CLASS_NAME(namespaced_name, "ZendTestForbidDynamicCall"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTestForbidDynamicCall_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL); #else @@ -1167,8 +1199,10 @@ static zend_class_entry *register_class_ZendTestIntEnum(void) static zend_class_entry *register_class_ZendTestNS_Foo(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "ZendTestNS", "Foo", class_ZendTestNS_Foo_methods); + INIT_CLASS_NAME_NS(namespaced_name, "ZendTestNS", "Foo"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTestNS_Foo_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); #else @@ -1181,8 +1215,10 @@ static zend_class_entry *register_class_ZendTestNS_Foo(void) static zend_class_entry *register_class_ZendTestNS_UnlikelyCompileError(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "ZendTestNS", "UnlikelyCompileError", class_ZendTestNS_UnlikelyCompileError_methods); + INIT_CLASS_NAME_NS(namespaced_name, "ZendTestNS", "UnlikelyCompileError"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTestNS_UnlikelyCompileError_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); #else @@ -1195,8 +1231,10 @@ static zend_class_entry *register_class_ZendTestNS_UnlikelyCompileError(void) static zend_class_entry *register_class_ZendTestNS_NotUnlikelyCompileError(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "ZendTestNS", "NotUnlikelyCompileError", class_ZendTestNS_NotUnlikelyCompileError_methods); + INIT_CLASS_NAME_NS(namespaced_name, "ZendTestNS", "NotUnlikelyCompileError"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTestNS_NotUnlikelyCompileError_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); #else @@ -1209,8 +1247,10 @@ static zend_class_entry *register_class_ZendTestNS_NotUnlikelyCompileError(void) static zend_class_entry *register_class_ZendTestNS2_Foo(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "ZendTestNS2", "Foo", class_ZendTestNS2_Foo_methods); + INIT_CLASS_NAME_NS(namespaced_name, "ZendTestNS2", "Foo"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTestNS2_Foo_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); #else @@ -1230,8 +1270,10 @@ static zend_class_entry *register_class_ZendTestNS2_Foo(void) static zend_class_entry *register_class_ZendTestNS2_ZendSubNS_Foo(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_NS_CLASS_ENTRY(ce, "ZendTestNS2\\ZendSubNS", "Foo", class_ZendTestNS2_ZendSubNS_Foo_methods); + INIT_CLASS_NAME_NS(namespaced_name, "ZendTestNS2\\ZendSubNS", "Foo"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZendTestNS2_ZendSubNS_Foo_methods); #if (PHP_VERSION_ID >= 80400) class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); #else diff --git a/ext/zip/php_zip.c b/ext/zip/php_zip.c index 65a835867f591..e2f0e82f0b6ef 100644 --- a/ext/zip/php_zip.c +++ b/ext/zip/php_zip.c @@ -918,7 +918,7 @@ static zval *php_zip_write_property(zend_object *object, zend_string *name, zval } if (hnd != NULL) { - zend_throw_error(NULL, "Cannot write read-only property %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(name)); + zend_throw_error(NULL, "Cannot write read-only property %s::$%s", ZSTR_VAL(object->ce->namespaced_name.name), ZSTR_VAL(name)); return &EG(error_zval); } diff --git a/ext/zip/php_zip_arginfo.h b/ext/zip/php_zip_arginfo.h index 6166218b2d8dd..abc4fa3d6e129 100644 --- a/ext/zip/php_zip_arginfo.h +++ b/ext/zip/php_zip_arginfo.h @@ -578,8 +578,10 @@ static void register_php_zip_symbols(int module_number) static zend_class_entry *register_class_ZipArchive(zend_class_entry *class_entry_Countable) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "ZipArchive", class_ZipArchive_methods); + INIT_CLASS_NAME(namespaced_name, "ZipArchive"); + INIT_CLASS_ENTRY(ce, namespaced_name, class_ZipArchive_methods); class_entry = zend_register_internal_class_with_flags(&ce, NULL, 0); zend_class_implements(class_entry, 1, class_entry_Countable); diff --git a/ext/zlib/zlib_arginfo.h b/ext/zlib/zlib_arginfo.h index 81d779c1b7d17..39190b1f0bc57 100644 --- a/ext/zlib/zlib_arginfo.h +++ b/ext/zlib/zlib_arginfo.h @@ -230,8 +230,10 @@ static void register_zlib_symbols(int module_number) static zend_class_entry *register_class_InflateContext(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "InflateContext", NULL); + INIT_CLASS_NAME(namespaced_name, "InflateContext"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; @@ -240,8 +242,10 @@ static zend_class_entry *register_class_InflateContext(void) static zend_class_entry *register_class_DeflateContext(void) { zend_class_entry ce, *class_entry; + zend_namespaced_name namespaced_name; - INIT_CLASS_ENTRY(ce, "DeflateContext", NULL); + INIT_CLASS_NAME(namespaced_name, "DeflateContext"); + INIT_CLASS_ENTRY(ce, namespaced_name, NULL); class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); return class_entry; diff --git a/main/streams/userspace.c b/main/streams/userspace.c index 0bb80acf6b7c2..95301bdff3acc 100644 --- a/main/streams/userspace.c +++ b/main/streams/userspace.c @@ -360,7 +360,7 @@ static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, const char * ZVAL_COPY(&stream->wrapperdata, &us->object); } else { php_stream_wrapper_log_error(wrapper, options, "\"%s::" USERSTREAM_OPEN "\" call failed", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); } /* destroy everything else */ @@ -436,7 +436,7 @@ static php_stream *user_wrapper_opendir(php_stream_wrapper *wrapper, const char ZVAL_COPY(&stream->wrapperdata, &us->object); } else { php_stream_wrapper_log_error(wrapper, options, "\"%s::" USERSTREAM_DIR_OPEN "\" call failed", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); } /* destroy everything else */ @@ -490,7 +490,7 @@ PHP_FUNCTION(stream_wrapper_register) php_error_docref(NULL, E_WARNING, "Protocol %s:// is already defined.", ZSTR_VAL(protocol)); } else { /* Hash doesn't exist so it must have been an invalid protocol scheme */ - php_error_docref(NULL, E_WARNING, "Invalid protocol scheme specified. Unable to register wrapper class %s to %s://", ZSTR_VAL(uwrap->ce->name), ZSTR_VAL(protocol)); + php_error_docref(NULL, E_WARNING, "Invalid protocol scheme specified. Unable to register wrapper class %s to %s://", ZSTR_VAL(uwrap->ce->namespaced_name.name), ZSTR_VAL(protocol)); } zend_list_delete(rsrc); @@ -592,14 +592,14 @@ static ssize_t php_userstreamop_write(php_stream *stream, const char *buf, size_ } } else { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_WRITE " is not implemented!", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); didwrite = -1; } /* don't allow strange buffer overruns due to bogus return */ if (didwrite > 0 && didwrite > count) { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_WRITE " wrote " ZEND_LONG_FMT " bytes more data than requested (" ZEND_LONG_FMT " written, " ZEND_LONG_FMT " max)", - ZSTR_VAL(us->wrapper->ce->name), + ZSTR_VAL(us->wrapper->ce->namespaced_name.name), (zend_long)(didwrite - count), (zend_long)didwrite, (zend_long)count); didwrite = count; } @@ -635,7 +635,7 @@ static ssize_t php_userstreamop_read(php_stream *stream, char *buf, size_t count if (call_result == FAILURE) { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_READ " is not implemented!", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); return -1; } @@ -652,7 +652,7 @@ static ssize_t php_userstreamop_read(php_stream *stream, char *buf, size_t count if (didread > 0) { if (didread > count) { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_READ " - read " ZEND_LONG_FMT " bytes more data than requested (" ZEND_LONG_FMT " read, " ZEND_LONG_FMT " max) - excess data will be lost", - ZSTR_VAL(us->wrapper->ce->name), (zend_long)(didread - count), (zend_long)didread, (zend_long)count); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name), (zend_long)(didread - count), (zend_long)didread, (zend_long)count); didread = count; } memcpy(buf, Z_STRVAL(retval), didread); @@ -677,7 +677,7 @@ static ssize_t php_userstreamop_read(php_stream *stream, char *buf, size_t count } else if (call_result == FAILURE) { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_EOF " is not implemented! Assuming EOF", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); stream->eof = 1; } @@ -785,7 +785,7 @@ static int php_userstreamop_seek(php_stream *stream, zend_off_t offset, int when *newoffs = Z_LVAL(retval); ret = 0; } else if (call_result == FAILURE) { - php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_TELL " is not implemented!", ZSTR_VAL(us->wrapper->ce->name)); + php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_TELL " is not implemented!", ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); ret = -1; } else { ret = -1; @@ -852,7 +852,7 @@ static int php_userstreamop_stat(php_stream *stream, php_stream_statbuf *ssb) } else { if (call_result == FAILURE) { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_STAT " is not implemented!", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); } } @@ -881,7 +881,7 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value ret = PHP_STREAM_OPTION_RETURN_ERR; php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_EOF " is not implemented! Assuming EOF", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); } zval_ptr_dtor(&retval); zval_ptr_dtor(&func_name); @@ -918,7 +918,7 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value ret = PHP_STREAM_OPTION_RETURN_OK; } else { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_LOCK " is not implemented!", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); ret = PHP_STREAM_OPTION_RETURN_ERR; } } @@ -951,12 +951,12 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value } else { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_TRUNCATE " did not return a boolean!", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); } } else { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_TRUNCATE " is not implemented!", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); } zval_ptr_dtor(&retval); zval_ptr_dtor(&args[0]); @@ -1007,7 +1007,7 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value if (call_result == FAILURE) { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_SET_OPTION " is not implemented!", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); ret = PHP_STREAM_OPTION_RETURN_ERR; } else if (zend_is_true(&retval)) { ret = PHP_STREAM_OPTION_RETURN_OK; @@ -1054,7 +1054,7 @@ static int user_wrapper_unlink(php_stream_wrapper *wrapper, const char *url, int if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) { ret = (Z_TYPE(zretval) == IS_TRUE); } else if (call_result == FAILURE) { - php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_UNLINK " is not implemented!", ZSTR_VAL(uwrap->ce->name)); + php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_UNLINK " is not implemented!", ZSTR_VAL(uwrap->ce->namespaced_name.name)); } /* clean up */ @@ -1094,7 +1094,7 @@ static int user_wrapper_rename(php_stream_wrapper *wrapper, const char *url_from if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) { ret = (Z_TYPE(zretval) == IS_TRUE); } else if (call_result == FAILURE) { - php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_RENAME " is not implemented!", ZSTR_VAL(uwrap->ce->name)); + php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_RENAME " is not implemented!", ZSTR_VAL(uwrap->ce->namespaced_name.name)); } /* clean up */ @@ -1136,7 +1136,7 @@ static int user_wrapper_mkdir(php_stream_wrapper *wrapper, const char *url, int if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) { ret = (Z_TYPE(zretval) == IS_TRUE); } else if (call_result == FAILURE) { - php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_MKDIR " is not implemented!", ZSTR_VAL(uwrap->ce->name)); + php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_MKDIR " is not implemented!", ZSTR_VAL(uwrap->ce->namespaced_name.name)); } /* clean up */ @@ -1178,7 +1178,7 @@ static int user_wrapper_rmdir(php_stream_wrapper *wrapper, const char *url, if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) { ret = (Z_TYPE(zretval) == IS_TRUE); } else if (call_result == FAILURE) { - php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_RMDIR " is not implemented!", ZSTR_VAL(uwrap->ce->name)); + php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_RMDIR " is not implemented!", ZSTR_VAL(uwrap->ce->namespaced_name.name)); } /* clean up */ @@ -1244,7 +1244,7 @@ static int user_wrapper_metadata(php_stream_wrapper *wrapper, const char *url, i if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) { ret = Z_TYPE(zretval) == IS_TRUE; } else if (call_result == FAILURE) { - php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_METADATA " is not implemented!", ZSTR_VAL(uwrap->ce->name)); + php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_METADATA " is not implemented!", ZSTR_VAL(uwrap->ce->namespaced_name.name)); } /* clean up */ @@ -1291,7 +1291,7 @@ static int user_wrapper_stat_url(php_stream_wrapper *wrapper, const char *url, i } else { if (call_result == FAILURE) { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_STATURL " is not implemented!", - ZSTR_VAL(uwrap->ce->name)); + ZSTR_VAL(uwrap->ce->namespaced_name.name)); } } @@ -1332,7 +1332,7 @@ static ssize_t php_userstreamop_readdir(php_stream *stream, char *buf, size_t co didread = sizeof(php_stream_dirent); } else if (call_result == FAILURE) { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_DIR_READ " is not implemented!", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); } zval_ptr_dtor(&retval); @@ -1409,7 +1409,7 @@ static int php_userstreamop_cast(php_stream *stream, int castas, void **retptr) if (call_result == FAILURE) { if (report_errors) { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_CAST " is not implemented!", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); } break; } @@ -1420,14 +1420,14 @@ static int php_userstreamop_cast(php_stream *stream, int castas, void **retptr) if (!intstream) { if (report_errors) { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_CAST " must return a stream resource", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); } break; } if (intstream == stream) { if (report_errors) { php_error_docref(NULL, E_WARNING, "%s::" USERSTREAM_CAST " must not return itself", - ZSTR_VAL(us->wrapper->ce->name)); + ZSTR_VAL(us->wrapper->ce->namespaced_name.name)); } intstream = NULL; break; diff --git a/tests/classes/inner_classes/access_modifiers_001.phpt b/tests/classes/inner_classes/access_modifiers_001.phpt new file mode 100644 index 0000000000000..ac1ce71cd3d40 --- /dev/null +++ b/tests/classes/inner_classes/access_modifiers_001.phpt @@ -0,0 +1,13 @@ +--TEST-- +multiple access modifiers +--FILE-- + +--EXPECTF-- +Fatal error: Multiple access type modifiers are not allowed in %s on line %d diff --git a/tests/classes/inner_classes/access_modifiers_002.phpt b/tests/classes/inner_classes/access_modifiers_002.phpt new file mode 100644 index 0000000000000..9c9eee89387b0 --- /dev/null +++ b/tests/classes/inner_classes/access_modifiers_002.phpt @@ -0,0 +1,13 @@ +--TEST-- +invalid inner class +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected identifier "int", expecting "class" in %s on line %d diff --git a/tests/classes/inner_classes/access_modifiers_003.phpt b/tests/classes/inner_classes/access_modifiers_003.phpt new file mode 100644 index 0000000000000..3dd79008daa60 --- /dev/null +++ b/tests/classes/inner_classes/access_modifiers_003.phpt @@ -0,0 +1,13 @@ +--TEST-- +static access modifiers +--FILE-- + +--EXPECTF-- +Fatal error: Cannot use the static modifier on a inner class in %s on line %d diff --git a/tests/classes/inner_classes/access_modifiers_004.phpt b/tests/classes/inner_classes/access_modifiers_004.phpt new file mode 100644 index 0000000000000..a4e86484ed9ec --- /dev/null +++ b/tests/classes/inner_classes/access_modifiers_004.phpt @@ -0,0 +1,13 @@ +--TEST-- +public(set) inner class +--FILE-- + +--EXPECTF-- +Fatal error: Cannot use the public(set) modifier on a inner class in %s on line %d diff --git a/tests/classes/inner_classes/access_modifiers_005.phpt b/tests/classes/inner_classes/access_modifiers_005.phpt new file mode 100644 index 0000000000000..82d7f0e93676c --- /dev/null +++ b/tests/classes/inner_classes/access_modifiers_005.phpt @@ -0,0 +1,13 @@ +--TEST-- +protected(set) inner class +--FILE-- + +--EXPECTF-- +Fatal error: Cannot use the protected(set) modifier on a inner class in %s on line %d diff --git a/tests/classes/inner_classes/access_modifiers_006.phpt b/tests/classes/inner_classes/access_modifiers_006.phpt new file mode 100644 index 0000000000000..41266b10b453f --- /dev/null +++ b/tests/classes/inner_classes/access_modifiers_006.phpt @@ -0,0 +1,13 @@ +--TEST-- +private(set) inner class +--FILE-- + +--EXPECTF-- +Fatal error: Cannot use the private(set) modifier on a inner class in %s on line %d diff --git a/tests/classes/inner_classes/access_modifiers_007.phpt b/tests/classes/inner_classes/access_modifiers_007.phpt new file mode 100644 index 0000000000000..88b9071b958cc --- /dev/null +++ b/tests/classes/inner_classes/access_modifiers_007.phpt @@ -0,0 +1,27 @@ +--TEST-- +abstract inner classes +--FILE-- +isAbstract()); +new Outer\Inner(); +?> +--EXPECTF-- +object(Extended)#1 (0) { +} +bool(true) + +Fatal error: Uncaught Error: Cannot instantiate abstract class Outer\Inner in %s:%d +Stack trace: +#0 {main} + thrown in %s on line %d diff --git a/tests/classes/inner_classes/autoload_001.phpt b/tests/classes/inner_classes/autoload_001.phpt new file mode 100644 index 0000000000000..5452d6491a5cc --- /dev/null +++ b/tests/classes/inner_classes/autoload_001.phpt @@ -0,0 +1,17 @@ +--TEST-- +ensure autoloading works +--FILE-- +x, ' ', $point->y, "\n"; +?> +--EXPECT-- +autoload(inner_classes) +1 2 diff --git a/tests/classes/inner_classes/autoload_002.phpt b/tests/classes/inner_classes/autoload_002.phpt new file mode 100644 index 0000000000000..6cb183bab3936 --- /dev/null +++ b/tests/classes/inner_classes/autoload_002.phpt @@ -0,0 +1,16 @@ +--TEST-- +ensure private autoloading works +--FILE-- + +--EXPECTF-- +autoload(inner_classes) + +Fatal error: Cannot instantiate "inner_classes\Line" from the global scope in %s on line %d diff --git a/tests/classes/inner_classes/enum_usage.phpt b/tests/classes/inner_classes/enum_usage.phpt new file mode 100644 index 0000000000000..00b2c5f755a55 --- /dev/null +++ b/tests/classes/inner_classes/enum_usage.phpt @@ -0,0 +1,16 @@ +--TEST-- +usage in an enum +--FILE-- + +--EXPECT-- +object(Outer\Inner)#1 (0) { +} +bool(true) diff --git a/tests/classes/inner_classes/errors_001.phpt b/tests/classes/inner_classes/errors_001.phpt new file mode 100644 index 0000000000000..d03109ea5af51 --- /dev/null +++ b/tests/classes/inner_classes/errors_001.phpt @@ -0,0 +1,12 @@ +--TEST-- +no outer class +--FILE-- + +--EXPECTF-- +Fatal error: Uncaught Error: Class "Outer\Inner" not found in %s:%d +Stack trace: +#0 {main} + thrown in %s on line %d diff --git a/tests/classes/inner_classes/errors_002.phpt b/tests/classes/inner_classes/errors_002.phpt new file mode 100644 index 0000000000000..883310c6705d0 --- /dev/null +++ b/tests/classes/inner_classes/errors_002.phpt @@ -0,0 +1,15 @@ +--TEST-- +inner class not found +--FILE-- + +--EXPECTF-- +Fatal error: Uncaught Error: Class "Outer\Inner" not found in %s:%d +Stack trace: +#0 {main} + thrown in %s on line %d diff --git a/tests/classes/inner_classes/inheritance.phpt b/tests/classes/inner_classes/inheritance.phpt new file mode 100644 index 0000000000000..4f2a9f3927619 --- /dev/null +++ b/tests/classes/inner_classes/inheritance.phpt @@ -0,0 +1,14 @@ +--TEST-- +inheritance +--FILE-- + +--EXPECT-- diff --git a/tests/classes/inner_classes/inner_classes.inc b/tests/classes/inner_classes/inner_classes.inc new file mode 100644 index 0000000000000..793804cf6606e --- /dev/null +++ b/tests/classes/inner_classes/inner_classes.inc @@ -0,0 +1,9 @@ + +--EXPECT-- +object(Outer\Inner)#1 (0) { +} +bool(true) +bool(false) diff --git a/tests/classes/inner_classes/readonly_001.phpt b/tests/classes/inner_classes/readonly_001.phpt new file mode 100644 index 0000000000000..3fb85996605a3 --- /dev/null +++ b/tests/classes/inner_classes/readonly_001.phpt @@ -0,0 +1,23 @@ +--TEST-- +readonly should work +--FILE-- +t = 42; +var_dump($foo); +?> +--EXPECTF-- +object(Outer\Inner)#1 (1) { + ["t"]=> + int(1) +} + +Fatal error: Uncaught Error: Cannot modify readonly property Outer\Inner::$t in %s:%d +Stack trace: +#0 {main} + thrown in %s on line %d diff --git a/tests/classes/inner_classes/reflection_001.phpt b/tests/classes/inner_classes/reflection_001.phpt new file mode 100644 index 0000000000000..0965778ff190f --- /dev/null +++ b/tests/classes/inner_classes/reflection_001.phpt @@ -0,0 +1,31 @@ +--TEST-- +reflection on inner classes +--FILE-- +getName()); +var_dump($ref->getShortName()); +var_dump($ref->isInnerClass()); +var_dump($outer->isInnerClass()); +var_dump($ref->isPrivate()); +var_dump($ref->isProtected()); +var_dump($ref->isPublic()); +?> +--EXPECT-- +string(22) "n\s\Outer\Middle\Inner" +string(5) "Inner" +bool(true) +bool(false) +bool(false) +bool(false) +bool(true) diff --git a/tests/classes/inner_classes/return_types_001.phpt b/tests/classes/inner_classes/return_types_001.phpt new file mode 100644 index 0000000000000..7e0be2a21b3a7 --- /dev/null +++ b/tests/classes/inner_classes/return_types_001.phpt @@ -0,0 +1,18 @@ +--TEST-- +test return types +--FILE-- + +--EXPECT-- +object(Outer\Inner)#1 (0) { +} diff --git a/tests/classes/inner_classes/return_types_002.phpt b/tests/classes/inner_classes/return_types_002.phpt new file mode 100644 index 0000000000000..a3e6eef60b535 --- /dev/null +++ b/tests/classes/inner_classes/return_types_002.phpt @@ -0,0 +1,32 @@ +--TEST-- +private inner class +--FILE-- +getInner(); + } +} + +class Foo extends Outer { + public function getInner(): Outer\Inner { + var_dump(parent::getInner2()); + return new Outer\Inner(); + } +} + +$outer = new Foo(); +var_dump($outer->getInner()); +?> +--EXPECTF-- +object(Outer\Inner)#2 (0) { +} + +Fatal error: Cannot instantiate private "Outer\Inner" from "Foo" in %s on line %d diff --git a/tests/classes/inner_classes/return_types_003.phpt b/tests/classes/inner_classes/return_types_003.phpt new file mode 100644 index 0000000000000..7b4b392167e0a --- /dev/null +++ b/tests/classes/inner_classes/return_types_003.phpt @@ -0,0 +1,33 @@ +--TEST-- +protected inner class +--FILE-- +getInner()); +var_dump(new Outer\Inner()); +?> +--EXPECTF-- +object(Outer\Inner)#2 (0) { +} + +Fatal error: Uncaught TypeError: Public method getInner cannot return protected class Outer\Inner in %s:%d +Stack trace: +#0 %s(%d): Foo->getInner() +#1 {main} + thrown in %s on line %d diff --git a/tests/classes/inner_classes/return_types_004.phpt b/tests/classes/inner_classes/return_types_004.phpt new file mode 100644 index 0000000000000..a5c8635031aa6 --- /dev/null +++ b/tests/classes/inner_classes/return_types_004.phpt @@ -0,0 +1,26 @@ +--TEST-- +private return types +--FILE-- + +--EXPECTF-- +Fatal error: Uncaught TypeError: Public method getInner cannot return private class Outer\Inner in %s:%d +Stack trace: +#0 %s(%d): Outer::getInner() +#1 {main} + thrown in %s on line %d diff --git a/tests/classes/inner_classes/return_types_005.phpt b/tests/classes/inner_classes/return_types_005.phpt new file mode 100644 index 0000000000000..dbb4f15ddcc24 --- /dev/null +++ b/tests/classes/inner_classes/return_types_005.phpt @@ -0,0 +1,26 @@ +--TEST-- +protected return types +--FILE-- + +--EXPECTF-- +Fatal error: Uncaught TypeError: Public method getInner cannot return protected class Outer\Inner in %s:%d +Stack trace: +#0 %s(%d): Outer::getInner() +#1 {main} + thrown in %s on line %d diff --git a/tests/classes/inner_classes/return_types_006.phpt b/tests/classes/inner_classes/return_types_006.phpt new file mode 100644 index 0000000000000..d530496a28b35 --- /dev/null +++ b/tests/classes/inner_classes/return_types_006.phpt @@ -0,0 +1,21 @@ +--TEST-- +returning private inner from inner method +--FILE-- +test(); } +} + +$foo = new Outer()->test(); +var_dump($foo); +?> +--EXPECT-- +object(Outer\PrivateInner)#3 (0) { +} diff --git a/tests/classes/inner_classes/simple_declaration_001.phpt b/tests/classes/inner_classes/simple_declaration_001.phpt new file mode 100644 index 0000000000000..93e9b16f4b241 --- /dev/null +++ b/tests/classes/inner_classes/simple_declaration_001.phpt @@ -0,0 +1,21 @@ +--TEST-- +simple declaration +--FILE-- + +--EXPECT-- +bool(true) +bool(true) +bool(true) +bool(true) diff --git a/tests/classes/inner_classes/simple_declaration_002.phpt b/tests/classes/inner_classes/simple_declaration_002.phpt new file mode 100644 index 0000000000000..d129f17a7b0a5 --- /dev/null +++ b/tests/classes/inner_classes/simple_declaration_002.phpt @@ -0,0 +1,13 @@ +--TEST-- +nested inside function +--FILE-- + +--EXPECTF-- +Fatal error: Class declarations may not be declared inside functions in %s on line %d diff --git a/tests/classes/inner_classes/simple_declaration_003.phpt b/tests/classes/inner_classes/simple_declaration_003.phpt new file mode 100644 index 0000000000000..1d8c59fd64ef2 --- /dev/null +++ b/tests/classes/inner_classes/simple_declaration_003.phpt @@ -0,0 +1,20 @@ +--TEST-- +basic nested classes +--FILE-- +test(); +?> +--EXPECT-- +Foo\Outer\Middle\Inner diff --git a/tests/classes/inner_classes/simple_declaration_004.phpt b/tests/classes/inner_classes/simple_declaration_004.phpt new file mode 100644 index 0000000000000..c430abac7b77c --- /dev/null +++ b/tests/classes/inner_classes/simple_declaration_004.phpt @@ -0,0 +1,41 @@ +--TEST-- +scope resolution access +--FILE-- + +--EXPECT-- +object(Outer\Middle)#1 (0) { +} +object(Outer\Middle)#1 (0) { +} +object(Outer2\Middle)#1 (0) { +} +object(Outer2\Middle)#1 (0) { +} diff --git a/tests/classes/inner_classes/static_variables.phpt b/tests/classes/inner_classes/static_variables.phpt new file mode 100644 index 0000000000000..debe1a5198e2c --- /dev/null +++ b/tests/classes/inner_classes/static_variables.phpt @@ -0,0 +1,30 @@ +--TEST-- +::class, statics, and inner classes +--FILE-- + +--EXPECT-- +string(12) "Outer\Middle" +string(3) "foo" +int(42) +string(18) "Outer\Middle\Inner" +string(3) "foo" +int(42) diff --git a/tests/classes/inner_classes/trait_usage.phpt b/tests/classes/inner_classes/trait_usage.phpt new file mode 100644 index 0000000000000..6e618e1a09387 --- /dev/null +++ b/tests/classes/inner_classes/trait_usage.phpt @@ -0,0 +1,24 @@ +--TEST-- +usage inside a trait +--FILE-- + +--EXPECT-- +object(Outer\Inner)#1 (0) { +} +bool(true) +bool(false) diff --git a/tests/classes/inner_classes/visibility_001.phpt b/tests/classes/inner_classes/visibility_001.phpt new file mode 100644 index 0000000000000..4b12e4271d5b4 --- /dev/null +++ b/tests/classes/inner_classes/visibility_001.phpt @@ -0,0 +1,25 @@ +--TEST-- +outer class visibility +--FILE-- +illegal = new Inner(); + } +} + +$x = new Outer(); +$x->test(); + +var_dump($x); +?> +--EXPECTF-- +Fatal error: Uncaught TypeError: Cannot assign private Outer\Inner to higher visibile property Outer::illegal in %s:%d +Stack trace: +#0 %s(%d): Outer->test() +#1 {main} + thrown in %s on line %d diff --git a/tests/classes/inner_classes/visibility_002.phpt b/tests/classes/inner_classes/visibility_002.phpt new file mode 100644 index 0000000000000..7444229361281 --- /dev/null +++ b/tests/classes/inner_classes/visibility_002.phpt @@ -0,0 +1,30 @@ +--TEST-- +accessing outer class private vars +--FILE-- +illegal = $this; + } + } + private Inner $illegal; + + public function test(): void { + new Inner()->test($this); + } +} + +$x = new Outer(); +$x->test(); + +var_dump($x); + +?> +--EXPECT-- +object(Outer)#1 (1) { + ["illegal":"Outer":private]=> + object(Outer\Inner)#2 (0) { + } +} diff --git a/tests/classes/inner_classes/visibility_003.phpt b/tests/classes/inner_classes/visibility_003.phpt new file mode 100644 index 0000000000000..07cbf29767ca0 --- /dev/null +++ b/tests/classes/inner_classes/visibility_003.phpt @@ -0,0 +1,30 @@ +--TEST-- +accessing outer protected vars +--FILE-- +illegal = $this; + } + } + private Inner $illegal; + + public function test(): void { + new Inner()->test($this); + } +} + +$x = new Outer(); +$x->test(); + +var_dump($x); + +?> +--EXPECT-- +object(Outer)#1 (1) { + ["illegal":"Outer":private]=> + object(Outer\Inner)#2 (0) { + } +} diff --git a/tests/classes/inner_classes/visibility_004.phpt b/tests/classes/inner_classes/visibility_004.phpt new file mode 100644 index 0000000000000..c655bbe2c8b29 --- /dev/null +++ b/tests/classes/inner_classes/visibility_004.phpt @@ -0,0 +1,25 @@ +--TEST-- +outer class visibility +--FILE-- +illegal = new Inner(); + } +} + +$x = new Outer(); +$x->test(); + +var_dump($x); +?> +--EXPECTF-- +Fatal error: Uncaught TypeError: Cannot assign protected Outer\Inner to higher visibile property Outer::illegal in %s:%d +Stack trace: +#0 %s(%d): Outer->test() +#1 {main} + thrown in %s on line %d diff --git a/tests/classes/inner_classes/visibility_005.phpt b/tests/classes/inner_classes/visibility_005.phpt new file mode 100644 index 0000000000000..8624c36245220 --- /dev/null +++ b/tests/classes/inner_classes/visibility_005.phpt @@ -0,0 +1,27 @@ +--TEST-- +accessing outer private methods +--FILE-- +test(); + } + } + } +} +new Outer\Middle\Inner()->test(); +?> +--EXPECT-- +Outer\Middle::test +Outer::test diff --git a/tests/classes/inner_classes/visibility_006.phpt b/tests/classes/inner_classes/visibility_006.phpt new file mode 100644 index 0000000000000..de15166bb551b --- /dev/null +++ b/tests/classes/inner_classes/visibility_006.phpt @@ -0,0 +1,28 @@ +--TEST-- +scope doesn't bypass scope +--FILE-- +test(); + } + } + } +} +new Outer\Middle\Inner()->testit(); +?> +--EXPECTF-- +Fatal error: Uncaught Error: Call to undefined method Outer\Middle\Inner::test() in %s:%d +Stack trace: +#0 %s(%d): Outer\Middle\Inner->testit() +#1 {main} + thrown in %s on line %d diff --git a/tests/classes/inner_classes/visibility_007.phpt b/tests/classes/inner_classes/visibility_007.phpt new file mode 100644 index 0000000000000..3da65bface64a --- /dev/null +++ b/tests/classes/inner_classes/visibility_007.phpt @@ -0,0 +1,27 @@ +--TEST-- +accessing outer protected methods +--FILE-- +test(); + } + } + } +} +new Outer\Middle\Inner()->test(); +?> +--EXPECT-- +Outer\Middle::test +Outer::test diff --git a/tests/classes/inner_classes/visibility_008.phpt b/tests/classes/inner_classes/visibility_008.phpt new file mode 100644 index 0000000000000..cbb8657fc632e --- /dev/null +++ b/tests/classes/inner_classes/visibility_008.phpt @@ -0,0 +1,30 @@ +--TEST-- +accessing sibling methods +--FILE-- +test(); + } + } +} +new Other\Inner()->test(); +?> +--EXPECT-- +Outer\Middle::test +Outer::test diff --git a/tests/classes/inner_classes/visibility_009.phpt b/tests/classes/inner_classes/visibility_009.phpt new file mode 100644 index 0000000000000..3c267d109984b --- /dev/null +++ b/tests/classes/inner_classes/visibility_009.phpt @@ -0,0 +1,38 @@ +--TEST-- +deeply nested property visibility +--FILE-- +i = 42; + var_dump($foo); + $foo = new Middle(); + $foo->i = 42; + var_dump($foo); + } + } + } +} +Outer\Middle\Inner::test(); +?> +--EXPECT-- +int(5) +int(42) +object(Outer)#1 (1) { + ["i":"Outer":private]=> + int(42) +} +object(Outer\Middle)#2 (1) { + ["i":"Outer\Middle":private]=> + int(42) +} diff --git a/tests/classes/inner_classes/visibility_010.phpt b/tests/classes/inner_classes/visibility_010.phpt new file mode 100644 index 0000000000000..b6e94ddf7d359 --- /dev/null +++ b/tests/classes/inner_classes/visibility_010.phpt @@ -0,0 +1,41 @@ +--TEST-- +constructors +--FILE-- +name = $builder->name; + $this->email = $builder->email; + } + + public readonly final class Builder { + public function __construct(public private(set) string|null $name = null, public private(set) string|null $email = null) {} + + public function withEmail(string $email): self { + return new self($this->name, $email); + } + + public function withName(string $name): self { + return new self($name, $this->email); + } + + public function build(): User { + return new User($this); + } + } +} + +$user = new User\Builder()->withName('Rob')->withEmail('rob@example.com')->build(); +var_dump($user); +?> +--EXPECT-- +object(User)#2 (2) { + ["name"]=> + string(3) "Rob" + ["email"]=> + string(15) "rob@example.com" +}