diff options
Diffstat (limited to 'ext/reflection/php_reflection.c')
| -rw-r--r-- | ext/reflection/php_reflection.c | 1918 |
1 files changed, 833 insertions, 1085 deletions
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index dbfb67386e..278e565874 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -1,7 +1,5 @@ /* +----------------------------------------------------------------------+ - | PHP Version 7 | - +----------------------------------------------------------------------+ | Copyright (c) The PHP Group | +----------------------------------------------------------------------+ | This source file is subject to version 3.01 of the PHP license, | @@ -43,6 +41,7 @@ #include "zend_extensions.h" #include "zend_builtin_functions.h" #include "zend_smart_str.h" +#include "php_reflection_arginfo.h" /* Key used to avoid leaking addresses in ReflectionProperty::getId() */ #define REFLECTION_KEY_LEN 16 @@ -76,6 +75,7 @@ PHPAPI zend_class_entry *reflection_generator_ptr; PHPAPI zend_class_entry *reflection_parameter_ptr; PHPAPI zend_class_entry *reflection_type_ptr; PHPAPI zend_class_entry *reflection_named_type_ptr; +PHPAPI zend_class_entry *reflection_union_type_ptr; PHPAPI zend_class_entry *reflection_class_ptr; PHPAPI zend_class_entry *reflection_object_ptr; PHPAPI zend_class_entry *reflection_method_ptr; @@ -93,10 +93,10 @@ PHPAPI zend_class_entry *reflection_reference_ptr; intern = Z_REFLECTION_P(ZEND_THIS); \ if (intern->ptr == NULL) { \ if (EG(exception) && EG(exception)->ce == reflection_exception_ptr) { \ - return; \ + RETURN_THROWS(); \ } \ zend_throw_error(NULL, "Internal error: Failed to retrieve the reflection object"); \ - return; \ + RETURN_THROWS(); \ } \ } while (0) @@ -113,9 +113,8 @@ PHPAPI zend_class_entry *reflection_reference_ptr; /* Struct for properties */ typedef struct _property_reference { - zend_property_info prop; + zend_property_info *prop; zend_string *unmangled_name; - zend_bool dynamic; } property_reference; /* Struct for parameters */ @@ -129,6 +128,8 @@ typedef struct _parameter_reference { /* Struct for type hints */ typedef struct _type_reference { zend_type type; + /* Whether to use backwards compatible null representation */ + zend_bool legacy_behavior; } type_reference; typedef enum { @@ -160,6 +161,10 @@ static inline reflection_object *reflection_object_from_obj(zend_object *obj) { static zend_object_handlers reflection_object_handlers; +static zend_always_inline uint32_t prop_get_flags(property_reference *ref) { + return ref->prop ? ref->prop->flags : ZEND_ACC_PUBLIC; +} + static inline zend_bool is_closure_invoke(zend_class_entry *ce, zend_string *lcname) { return ce == zend_ce_closure && zend_string_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME); @@ -226,7 +231,7 @@ static void reflection_free_objects_storage(zend_object *object) /* {{{ */ case REF_TYPE_TYPE: { type_reference *type_ref = intern->ptr; - if (ZEND_TYPE_IS_NAME(type_ref->type)) { + if (ZEND_TYPE_HAS_NAME(type_ref->type)) { zend_string_release(ZEND_TYPE_NAME(type_ref->type)); } efree(type_ref); @@ -252,9 +257,9 @@ static void reflection_free_objects_storage(zend_object *object) /* {{{ */ } /* }}} */ -static HashTable *reflection_get_gc(zval *obj, zval **gc_data, int *gc_data_count) /* {{{ */ +static HashTable *reflection_get_gc(zend_object *obj, zval **gc_data, int *gc_data_count) /* {{{ */ { - reflection_object *intern = Z_REFLECTION_P(obj); + reflection_object *intern = reflection_object_from_obj(obj); *gc_data = &intern->obj; *gc_data_count = 1; return zend_std_get_properties(obj); @@ -281,7 +286,7 @@ static zval *reflection_instantiate(zend_class_entry *pce, zval *object) /* {{{ static void _const_string(smart_str *str, char *name, zval *value, char *indent); static void _function_string(smart_str *str, zend_function *fptr, zend_class_entry *scope, char* indent); -static void _property_string(smart_str *str, zend_property_info *prop, const char *prop_name, char* indent, zend_bool dynamic); +static void _property_string(smart_str *str, zend_property_info *prop, const char *prop_name, char* indent); static void _class_const_string(smart_str *str, char *name, zend_class_constant *c, char* indent); static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, char *indent); static void _extension_string(smart_str *str, zend_module_entry *module, char *indent); @@ -396,7 +401,7 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, char ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop) { if ((prop->flags & ZEND_ACC_STATIC) && (!(prop->flags & ZEND_ACC_PRIVATE) || prop->ce == ce)) { - _property_string(str, prop, NULL, ZSTR_VAL(sub_indent), 0); + _property_string(str, prop, NULL, ZSTR_VAL(sub_indent)); } } ZEND_HASH_FOREACH_END(); } @@ -444,14 +449,14 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, char ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop) { if (!(prop->flags & ZEND_ACC_STATIC) && (!(prop->flags & ZEND_ACC_PRIVATE) || prop->ce == ce)) { - _property_string(str, prop, NULL, ZSTR_VAL(sub_indent), 0); + _property_string(str, prop, NULL, ZSTR_VAL(sub_indent)); } } ZEND_HASH_FOREACH_END(); } smart_str_append_printf(str, "%s }\n", indent); if (obj && Z_TYPE_P(obj) == IS_OBJECT) { - HashTable *properties = Z_OBJ_HT_P(obj)->get_properties(obj); + HashTable *properties = Z_OBJ_HT_P(obj)->get_properties(Z_OBJ_P(obj)); zend_string *prop_name; smart_str prop_str = {0}; @@ -461,7 +466,7 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, char if (prop_name && ZSTR_LEN(prop_name) && ZSTR_VAL(prop_name)[0]) { /* skip all private and protected properties */ if (!zend_hash_exists(&ce->properties_info, prop_name)) { count++; - _property_string(&prop_str, NULL, ZSTR_VAL(prop_name), ZSTR_VAL(sub_indent), 0); + _property_string(&prop_str, NULL, ZSTR_VAL(prop_name), ZSTR_VAL(sub_indent)); } } } ZEND_HASH_FOREACH_END(); @@ -518,7 +523,7 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, char /* {{{ _const_string */ static void _const_string(smart_str *str, char *name, zval *value, char *indent) { - char *type = zend_zval_type_name(value); + const char *type = zend_zval_type_name(value); if (Z_TYPE_P(value) == IS_ARRAY) { smart_str_append_printf(str, "%s Constant [ %s %s ] { Array }\n", @@ -540,7 +545,7 @@ static void _const_string(smart_str *str, char *name, zval *value, char *indent) static void _class_const_string(smart_str *str, char *name, zend_class_constant *c, char *indent) { char *visibility = zend_visibility_string(Z_ACCESS_FLAGS(c->value)); - char *type; + const char *type; zval_update_constant_ex(&c->value, c->ce); type = zend_zval_type_name(&c->value); @@ -579,6 +584,39 @@ static zend_op* _get_recv_op(zend_op_array *op_array, uint32_t offset) } /* }}} */ +static int format_default_value(smart_str *str, zval *value, zend_class_entry *scope) { + zval zv; + ZVAL_COPY(&zv, value); + if (UNEXPECTED(zval_update_constant_ex(&zv, scope) == FAILURE)) { + zval_ptr_dtor(&zv); + return FAILURE; + } + + if (Z_TYPE(zv) == IS_TRUE) { + smart_str_appends(str, "true"); + } else if (Z_TYPE(zv) == IS_FALSE) { + smart_str_appends(str, "false"); + } else if (Z_TYPE(zv) == IS_NULL) { + smart_str_appends(str, "NULL"); + } else if (Z_TYPE(zv) == IS_STRING) { + smart_str_appendc(str, '\''); + smart_str_appendl(str, Z_STRVAL(zv), MIN(Z_STRLEN(zv), 15)); + if (Z_STRLEN(zv) > 15) { + smart_str_appends(str, "..."); + } + smart_str_appendc(str, '\''); + } else if (Z_TYPE(zv) == IS_ARRAY) { + smart_str_appends(str, "Array"); + } else { + zend_string *tmp_zv_str; + zend_string *zv_str = zval_get_tmp_string(&zv, &tmp_zv_str); + smart_str_append(str, zv_str); + zend_tmp_string_release(tmp_zv_str); + } + zval_ptr_dtor(&zv); + return SUCCESS; +} + /* {{{ _parameter_string */ static void _parameter_string(smart_str *str, zend_function *fptr, struct _zend_arg_info *arg_info, uint32_t offset, zend_bool required, char* indent) { @@ -588,22 +626,16 @@ static void _parameter_string(smart_str *str, zend_function *fptr, struct _zend_ } else { smart_str_append_printf(str, "<required> "); } - if (ZEND_TYPE_IS_CLASS(arg_info->type)) { - smart_str_append_printf(str, "%s ", - ZSTR_VAL(ZEND_TYPE_NAME(arg_info->type))); - if (ZEND_TYPE_ALLOW_NULL(arg_info->type)) { - smart_str_append_printf(str, "or NULL "); - } - } else if (ZEND_TYPE_IS_CODE(arg_info->type)) { - smart_str_append_printf(str, "%s ", zend_get_type_by_const(ZEND_TYPE_CODE(arg_info->type))); - if (ZEND_TYPE_ALLOW_NULL(arg_info->type)) { - smart_str_append_printf(str, "or NULL "); - } + if (ZEND_TYPE_IS_SET(arg_info->type)) { + zend_string *type_str = zend_type_to_string(arg_info->type); + smart_str_append(str, type_str); + smart_str_appendc(str, ' '); + zend_string_release(type_str); } - if (arg_info->pass_by_reference) { + if (ZEND_ARG_SEND_MODE(arg_info)) { smart_str_appendc(str, '&'); } - if (arg_info->is_variadic) { + if (ZEND_ARG_IS_VARIADIC(arg_info)) { smart_str_appends(str, "..."); } if (arg_info->name) { @@ -618,36 +650,10 @@ static void _parameter_string(smart_str *str, zend_function *fptr, struct _zend_ if (fptr->type == ZEND_USER_FUNCTION && !required) { zend_op *precv = _get_recv_op((zend_op_array*)fptr, offset); if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) { - zval zv; - smart_str_appends(str, " = "); - ZVAL_COPY(&zv, RT_CONSTANT(precv, precv->op2)); - if (UNEXPECTED(zval_update_constant_ex(&zv, fptr->common.scope) == FAILURE)) { - zval_ptr_dtor(&zv); + if (format_default_value(str, RT_CONSTANT(precv, precv->op2), fptr->common.scope) == FAILURE) { return; } - if (Z_TYPE(zv) == IS_TRUE) { - smart_str_appends(str, "true"); - } else if (Z_TYPE(zv) == IS_FALSE) { - smart_str_appends(str, "false"); - } else if (Z_TYPE(zv) == IS_NULL) { - smart_str_appends(str, "NULL"); - } else if (Z_TYPE(zv) == IS_STRING) { - smart_str_appendc(str, '\''); - smart_str_appendl(str, Z_STRVAL(zv), MIN(Z_STRLEN(zv), 15)); - if (Z_STRLEN(zv) > 15) { - smart_str_appends(str, "..."); - } - smart_str_appendc(str, '\''); - } else if (Z_TYPE(zv) == IS_ARRAY) { - smart_str_appends(str, "Array"); - } else { - zend_string *tmp_zv_str; - zend_string *zv_str = zval_get_tmp_string(&zv, &tmp_zv_str); - smart_str_append(str, zv_str); - zend_tmp_string_release(tmp_zv_str); - } - zval_ptr_dtor(&zv); } } smart_str_appends(str, " ]"); @@ -808,17 +814,10 @@ static void _function_string(smart_str *str, zend_function *fptr, zend_class_ent smart_str_free(¶m_indent); if (fptr->op_array.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { smart_str_append_printf(str, " %s- Return [ ", indent); - if (ZEND_TYPE_IS_CLASS(fptr->common.arg_info[-1].type)) { - smart_str_append_printf(str, "%s ", - ZSTR_VAL(ZEND_TYPE_NAME(fptr->common.arg_info[-1].type))); - if (ZEND_TYPE_ALLOW_NULL(fptr->common.arg_info[-1].type)) { - smart_str_appends(str, "or NULL "); - } - } else if (ZEND_TYPE_IS_CODE(fptr->common.arg_info[-1].type)) { - smart_str_append_printf(str, "%s ", zend_get_type_by_const(ZEND_TYPE_CODE(fptr->common.arg_info[-1].type))); - if (ZEND_TYPE_ALLOW_NULL(fptr->common.arg_info[-1].type)) { - smart_str_appends(str, "or NULL "); - } + if (ZEND_TYPE_IS_SET(fptr->common.arg_info[-1].type)) { + zend_string *type_str = zend_type_to_string(fptr->common.arg_info[-1].type); + smart_str_append_printf(str, "%s ", ZSTR_VAL(type_str)); + zend_string_release(type_str); } smart_str_appends(str, "]\n"); } @@ -826,21 +825,24 @@ static void _function_string(smart_str *str, zend_function *fptr, zend_class_ent } /* }}} */ +static zval *property_get_default(zend_property_info *prop_info) { + zend_class_entry *ce = prop_info->ce; + if (prop_info->flags & ZEND_ACC_STATIC) { + zval *prop = &ce->default_static_members_table[prop_info->offset]; + ZVAL_DEINDIRECT(prop); + return prop; + } else { + return &ce->default_properties_table[OBJ_PROP_TO_NUM(prop_info->offset)]; + } +} + /* {{{ _property_string */ -static void _property_string(smart_str *str, zend_property_info *prop, const char *prop_name, char* indent, zend_bool dynamic) +static void _property_string(smart_str *str, zend_property_info *prop, const char *prop_name, char* indent) { smart_str_append_printf(str, "%sProperty [ ", indent); if (!prop) { smart_str_append_printf(str, "<dynamic> public $%s", prop_name); } else { - if (!(prop->flags & ZEND_ACC_STATIC)) { - if (dynamic) { - smart_str_appends(str, "<implicit> "); - } else { - smart_str_appends(str, "<default> "); - } - } - /* These are mutually exclusive */ switch (prop->flags & ZEND_ACC_PPP_MASK) { case ZEND_ACC_PUBLIC: @@ -856,11 +858,25 @@ static void _property_string(smart_str *str, zend_property_info *prop, const cha if (prop->flags & ZEND_ACC_STATIC) { smart_str_appends(str, "static "); } + if (ZEND_TYPE_IS_SET(prop->type)) { + zend_string *type_str = zend_type_to_string(prop->type); + smart_str_append(str, type_str); + smart_str_appendc(str, ' '); + zend_string_release(type_str); + } if (!prop_name) { const char *class_name; zend_unmangle_property_name(prop->name, &class_name, &prop_name); } smart_str_append_printf(str, "$%s", prop_name); + + zval *default_value = property_get_default(prop); + if (!Z_ISUNDEF_P(default_value)) { + smart_str_appends(str, " = "); + if (format_default_value(str, default_value, prop->ce) == FAILURE) { + return; + } + } } smart_str_appends(str, " ]\n"); @@ -1064,7 +1080,7 @@ static void _function_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) zend_function *mptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(mptr); RETURN_BOOL(mptr->common.fn_flags & mask); @@ -1146,22 +1162,46 @@ static void reflection_parameter_factory(zend_function *fptr, zval *closure_obje } /* }}} */ +/* For backwards compatibility reasons, we need to return T|null style unions + * as a ReflectionNamedType. Here we determine what counts as a union type and + * what doesn't. */ +static zend_bool is_union_type(zend_type type) { + if (ZEND_TYPE_HAS_LIST(type)) { + return 1; + } + uint32_t type_mask_without_null = ZEND_TYPE_PURE_MASK_WITHOUT_NULL(type); + if (ZEND_TYPE_HAS_CLASS(type)) { + return type_mask_without_null != 0; + } + if (type_mask_without_null == MAY_BE_BOOL) { + return 0; + } + /* Check that only one bit is set. */ + return (type_mask_without_null & (type_mask_without_null - 1)) != 0; +} + /* {{{ reflection_type_factory */ -static void reflection_type_factory(zend_type type, zval *object) +static void reflection_type_factory(zend_type type, zval *object, zend_bool legacy_behavior) { reflection_object *intern; type_reference *reference; + zend_bool is_union = is_union_type(type); - reflection_instantiate(reflection_named_type_ptr, object); + reflection_instantiate( + is_union ? reflection_union_type_ptr : reflection_named_type_ptr, object); intern = Z_REFLECTION_P(object); reference = (type_reference*) emalloc(sizeof(type_reference)); reference->type = type; + reference->legacy_behavior = legacy_behavior && !is_union; intern->ptr = reference; intern->ref_type = REF_TYPE_TYPE; - /* Property types may be resolved during the lifetime of the ReflectionType, - * so we need to make sure that the strings we reference are not released. */ - if (ZEND_TYPE_IS_NAME(type)) { + /* Property types may be resolved during the lifetime of the ReflectionType. + * If we reference a string, make sure it doesn't get released. However, only + * do this for the top-level type, as resolutions inside type lists will be + * fully visible to us (we'd have to do a fully copy of the type if we wanted + * to prevent that). */ + if (ZEND_TYPE_HAS_NAME(type)) { zend_string_addref(ZEND_TYPE_NAME(type)); } } @@ -1199,60 +1239,40 @@ static void reflection_method_factory(zend_class_entry *ce, zend_function *metho ZVAL_OBJ(&intern->obj, Z_OBJ_P(closure_object)); } - ZVAL_STR_COPY(reflection_prop_name(object), - (method->common.scope && method->common.scope->trait_aliases) - ? zend_resolve_method_name(ce, method) : method->common.function_name); + ZVAL_STR_COPY(reflection_prop_name(object), method->common.function_name); ZVAL_STR_COPY(reflection_prop_class(object), method->common.scope->name); } /* }}} */ /* {{{ reflection_property_factory */ -static void reflection_property_factory(zend_class_entry *ce, zend_string *name, zend_property_info *prop, zval *object, zend_bool dynamic) +static void reflection_property_factory(zend_class_entry *ce, zend_string *name, zend_property_info *prop, zval *object) { reflection_object *intern; property_reference *reference; - if (!(prop->flags & ZEND_ACC_PRIVATE)) { - /* we have to search the class hierarchy for this (implicit) public or protected property */ - zend_class_entry *tmp_ce = ce, *store_ce = ce; - zend_property_info *tmp_info = NULL; - - while (tmp_ce && (tmp_info = zend_hash_find_ptr(&tmp_ce->properties_info, name)) == NULL) { - ce = tmp_ce; - tmp_ce = tmp_ce->parent; - } - - if (tmp_info && (!(tmp_info->flags & ZEND_ACC_PRIVATE) || tmp_info->ce == tmp_ce)) { /* found something and it's not a parent's private */ - prop = tmp_info; - } else { /* not found, use initial value */ - ce = store_ce; - } - } - reflection_instantiate(reflection_property_ptr, object); intern = Z_REFLECTION_P(object); reference = (property_reference*) emalloc(sizeof(property_reference)); - reference->prop = *prop; + reference->prop = prop; reference->unmangled_name = zend_string_copy(name); - reference->dynamic = dynamic; intern->ptr = reference; intern->ref_type = REF_TYPE_PROPERTY; intern->ce = ce; intern->ignore_visibility = 0; ZVAL_STR_COPY(reflection_prop_name(object), name); - ZVAL_STR_COPY(reflection_prop_class(object), prop->ce->name); + ZVAL_STR_COPY(reflection_prop_class(object), prop ? prop->ce->name : ce->name); } /* }}} */ static void reflection_property_factory_str(zend_class_entry *ce, const char *name_str, size_t name_len, zend_property_info *prop, zval *object) { zend_string *name = zend_string_init(name_str, name_len, 0); - reflection_property_factory(ce, name, prop, object, 0); + reflection_property_factory(ce, name, prop, object); zend_string_release(name); } /* {{{ reflection_class_constant_factory */ -static void reflection_class_constant_factory(zend_class_entry *ce, zend_string *name_str, zend_class_constant *constant, zval *object) +static void reflection_class_constant_factory(zend_string *name_str, zend_class_constant *constant, zval *object) { reflection_object *intern; @@ -1264,102 +1284,7 @@ static void reflection_class_constant_factory(zend_class_entry *ce, zend_string intern->ignore_visibility = 0; ZVAL_STR_COPY(reflection_prop_name(object), name_str); - ZVAL_STR_COPY(reflection_prop_class(object), ce->name); -} -/* }}} */ - -static void reflection_export_impl(zval *return_value, zval *object, zend_bool return_output) { - zval fname, retval; - int result; - - /* Invoke the __toString() method */ - ZVAL_STRINGL(&fname, "__tostring", sizeof("__tostring") - 1); - result = call_user_function(NULL, object, &fname, &retval, 0, NULL); - zval_ptr_dtor_str(&fname); - - if (result == FAILURE) { - _DO_THROW("Invocation of method __toString() failed"); - return; - } - - if (Z_TYPE(retval) == IS_UNDEF) { - php_error_docref(NULL, E_WARNING, "%s::__toString() did not return anything", ZSTR_VAL(Z_OBJCE_P(object)->name)); - RETURN_FALSE; - } - - if (return_output) { - ZVAL_COPY_VALUE(return_value, &retval); - } else { - /* No need for _r variant, return of __toString should always be a string */ - zend_print_zval(&retval, 0); - zend_printf("\n"); - zval_ptr_dtor(&retval); - } -} - -/* {{{ _reflection_export */ -static void _reflection_export(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *ce_ptr, int ctor_argc) -{ - zval reflector; - zval *argument_ptr, *argument2_ptr; - zval retval, params[2]; - int result; - int return_output = 0; - zend_fcall_info fci; - zend_fcall_info_cache fcc; - - if (ctor_argc == 1) { - if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|b", &argument_ptr, &return_output) == FAILURE) { - return; - } - ZVAL_COPY_VALUE(¶ms[0], argument_ptr); - ZVAL_NULL(¶ms[1]); - } else { - if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz|b", &argument_ptr, &argument2_ptr, &return_output) == FAILURE) { - return; - } - ZVAL_COPY_VALUE(¶ms[0], argument_ptr); - ZVAL_COPY_VALUE(¶ms[1], argument2_ptr); - } - - /* Create object */ - if (object_init_ex(&reflector, ce_ptr) == FAILURE) { - _DO_THROW("Could not create reflector"); - return; - } - - /* Call __construct() */ - - fci.size = sizeof(fci); - ZVAL_UNDEF(&fci.function_name); - fci.object = Z_OBJ(reflector); - fci.retval = &retval; - fci.param_count = ctor_argc; - fci.params = params; - fci.no_separation = 1; - - fcc.function_handler = ce_ptr->constructor; - fcc.called_scope = Z_OBJCE(reflector); - fcc.object = Z_OBJ(reflector); - - result = zend_call_function(&fci, &fcc); - - zval_ptr_dtor(&retval); - - if (EG(exception)) { - zval_ptr_dtor(&reflector); - return; - } - if (result == FAILURE) { - zval_ptr_dtor(&reflector); - _DO_THROW("Could not create reflector"); - return; - } - - reflection_export_impl(return_value, &reflector, return_output); - - /* Destruct reflector which is no longer needed */ - zval_ptr_dtor(&reflector); + ZVAL_STR_COPY(reflection_prop_class(object), constant->ce->name); } /* }}} */ @@ -1415,23 +1340,6 @@ ZEND_METHOD(reflection, __clone) } /* }}} */ -/* {{{ proto public static mixed Reflection::export(Reflector r [, bool return]) - Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */ -ZEND_METHOD(reflection, export) -{ - zval *object; - zend_bool return_output = 0; - - ZEND_PARSE_PARAMETERS_START(1, 2) - Z_PARAM_OBJECT_OF_CLASS(object, reflector_ptr) - Z_PARAM_OPTIONAL - Z_PARAM_BOOL(return_output) - ZEND_PARSE_PARAMETERS_END(); - - reflection_export_impl(return_value, object, return_output); -} -/* }}} */ - /* {{{ proto public static array Reflection::getModifierNames(int modifiers) Returns an array of modifier names */ ZEND_METHOD(reflection, getModifierNames) @@ -1439,7 +1347,7 @@ ZEND_METHOD(reflection, getModifierNames) zend_long modifiers; if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &modifiers) == FAILURE) { - return; + RETURN_THROWS(); } array_init(return_value); @@ -1470,14 +1378,6 @@ ZEND_METHOD(reflection, getModifierNames) } /* }}} */ -/* {{{ proto public static mixed ReflectionFunction::export(string name [, bool return]) - Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */ -ZEND_METHOD(reflection_function, export) -{ - _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_function_ptr, 1); -} -/* }}} */ - /* {{{ proto public void ReflectionFunction::__construct(string name) Constructor. Throws an Exception in case the given function does not exist */ ZEND_METHOD(reflection_function, __construct) @@ -1497,8 +1397,8 @@ ZEND_METHOD(reflection_function, __construct) } else { ALLOCA_FLAG(use_heap) - if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "S", &fname) == FAILURE) { - return; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &fname) == FAILURE) { + RETURN_THROWS(); } if (UNEXPECTED(ZSTR_VAL(fname)[0] == '\\')) { @@ -1516,7 +1416,7 @@ ZEND_METHOD(reflection_function, __construct) if (fptr == NULL) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Function %s() does not exist", ZSTR_VAL(fname)); - return; + RETURN_THROWS(); } } @@ -1541,7 +1441,7 @@ ZEND_METHOD(reflection_function, __toString) smart_str str = {0}; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); _function_string(&str, fptr, intern->ce, ""); @@ -1554,7 +1454,7 @@ ZEND_METHOD(reflection_function, __toString) ZEND_METHOD(reflection_function, getName) { if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } _default_get_name(ZEND_THIS, return_value); } @@ -1568,7 +1468,7 @@ ZEND_METHOD(reflection_function, isClosure) zend_function *fptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); RETURN_BOOL(fptr->common.fn_flags & ZEND_ACC_CLOSURE); @@ -1583,7 +1483,7 @@ ZEND_METHOD(reflection_function, getClosureThis) zval* closure_this; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT(); if (!Z_ISUNDEF(intern->obj)) { @@ -1604,7 +1504,7 @@ ZEND_METHOD(reflection_function, getClosureScopeClass) const zend_function *closure_func; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT(); if (!Z_ISUNDEF(intern->obj)) { @@ -1624,7 +1524,7 @@ ZEND_METHOD(reflection_function, getClosure) zend_function *fptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); @@ -1646,7 +1546,7 @@ ZEND_METHOD(reflection_function, isInternal) zend_function *fptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); RETURN_BOOL(fptr->type == ZEND_INTERNAL_FUNCTION); @@ -1661,7 +1561,7 @@ ZEND_METHOD(reflection_function, isUserDefined) zend_function *fptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); RETURN_BOOL(fptr->type == ZEND_USER_FUNCTION); @@ -1676,6 +1576,11 @@ ZEND_METHOD(reflection_function, isDisabled) zend_function *fptr; GET_REFLECTION_OBJECT_PTR(fptr); + + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + RETURN_BOOL(fptr->type == ZEND_INTERNAL_FUNCTION && fptr->internal_function.handler == zif_display_disabled_function); } /* }}} */ @@ -1688,7 +1593,7 @@ ZEND_METHOD(reflection_function, getFileName) zend_function *fptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); if (fptr->type == ZEND_USER_FUNCTION) { @@ -1706,7 +1611,7 @@ ZEND_METHOD(reflection_function, getStartLine) zend_function *fptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); if (fptr->type == ZEND_USER_FUNCTION) { @@ -1724,7 +1629,7 @@ ZEND_METHOD(reflection_function, getEndLine) zend_function *fptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); if (fptr->type == ZEND_USER_FUNCTION) { @@ -1742,7 +1647,7 @@ ZEND_METHOD(reflection_function, getDocComment) zend_function *fptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.doc_comment) { @@ -1761,7 +1666,7 @@ ZEND_METHOD(reflection_function, getStaticVariables) zval *val; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); @@ -1803,7 +1708,7 @@ ZEND_METHOD(reflection_function, invoke) GET_REFLECTION_OBJECT_PTR(fptr); if (zend_parse_parameters(ZEND_NUM_ARGS(), "*", ¶ms, &num_args) == FAILURE) { - return; + RETURN_THROWS(); } fci.size = sizeof(fci); @@ -1820,7 +1725,7 @@ ZEND_METHOD(reflection_function, invoke) if (!Z_ISUNDEF(intern->obj)) { Z_OBJ_HT(intern->obj)->get_closure( - &intern->obj, &fcc.called_scope, &fcc.function_handler, &fcc.object); + Z_OBJ(intern->obj), &fcc.called_scope, &fcc.function_handler, &fcc.object, 0); } result = zend_call_function(&fci, &fcc); @@ -1828,7 +1733,7 @@ ZEND_METHOD(reflection_function, invoke) if (result == FAILURE) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Invocation of function %s() failed", ZSTR_VAL(fptr->common.function_name)); - return; + RETURN_THROWS(); } if (Z_TYPE(retval) != IS_UNDEF) { @@ -1857,7 +1762,7 @@ ZEND_METHOD(reflection_function, invokeArgs) GET_REFLECTION_OBJECT_PTR(fptr); if (zend_parse_parameters(ZEND_NUM_ARGS(), "a", ¶m_array) == FAILURE) { - return; + RETURN_THROWS(); } argc = zend_hash_num_elements(Z_ARRVAL_P(param_array)); @@ -1883,7 +1788,7 @@ ZEND_METHOD(reflection_function, invokeArgs) if (!Z_ISUNDEF(intern->obj)) { Z_OBJ_HT(intern->obj)->get_closure( - &intern->obj, &fcc.called_scope, &fcc.function_handler, &fcc.object); + Z_OBJ(intern->obj), &fcc.called_scope, &fcc.function_handler, &fcc.object, 0); } result = zend_call_function(&fci, &fcc); @@ -1896,7 +1801,7 @@ ZEND_METHOD(reflection_function, invokeArgs) if (result == FAILURE) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Invocation of function %s() failed", ZSTR_VAL(fptr->common.function_name)); - return; + RETURN_THROWS(); } if (Z_TYPE(retval) != IS_UNDEF) { @@ -1917,6 +1822,10 @@ ZEND_METHOD(reflection_function, returnsReference) GET_REFLECTION_OBJECT_PTR(fptr); + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + RETURN_BOOL((fptr->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0); } /* }}} */ @@ -1931,6 +1840,10 @@ ZEND_METHOD(reflection_function, getNumberOfParameters) GET_REFLECTION_OBJECT_PTR(fptr); + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + num_args = fptr->common.num_args; if (fptr->common.fn_flags & ZEND_ACC_VARIADIC) { num_args++; @@ -1949,6 +1862,10 @@ ZEND_METHOD(reflection_function, getNumberOfRequiredParameters) GET_REFLECTION_OBJECT_PTR(fptr); + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + RETURN_LONG(fptr->common.required_num_args); } /* }}} */ @@ -1964,6 +1881,10 @@ ZEND_METHOD(reflection_function, getParameters) GET_REFLECTION_OBJECT_PTR(fptr); + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + arg_info= fptr->common.arg_info; num_args = fptr->common.num_args; if (fptr->common.fn_flags & ZEND_ACC_VARIADIC) { @@ -2003,6 +1924,10 @@ ZEND_METHOD(reflection_function, getExtension) GET_REFLECTION_OBJECT_PTR(fptr); + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + if (fptr->type != ZEND_INTERNAL_FUNCTION) { RETURN_NULL(); } @@ -2026,6 +1951,10 @@ ZEND_METHOD(reflection_function, getExtensionName) GET_REFLECTION_OBJECT_PTR(fptr); + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + if (fptr->type != ZEND_INTERNAL_FUNCTION) { RETURN_FALSE; } @@ -2049,14 +1978,14 @@ ZEND_METHOD(reflection_generator, __construct) object = ZEND_THIS; intern = Z_REFLECTION_P(object); - if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "O", &generator, zend_ce_generator) == FAILURE) { - return; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &generator, zend_ce_generator) == FAILURE) { + RETURN_THROWS(); } ex = ((zend_generator *) Z_OBJ_P(generator))->execute_data; if (!ex) { _DO_THROW("Cannot create ReflectionGenerator based on a terminated Generator"); - return; + RETURN_THROWS(); } intern->ref_type = REF_TYPE_GENERATOR; @@ -2069,7 +1998,7 @@ ZEND_METHOD(reflection_generator, __construct) #define REFLECTION_CHECK_VALID_GENERATOR(ex) \ if (!ex) { \ _DO_THROW("Cannot fetch information from a terminated Generator"); \ - return; \ + RETURN_THROWS(); \ } /* {{{ proto public array ReflectionGenerator::getTrace($options = DEBUG_BACKTRACE_PROVIDE_OBJECT) */ @@ -2083,7 +2012,7 @@ ZEND_METHOD(reflection_generator, getTrace) zend_execute_data *root_prev = NULL, *cur_prev; if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &options) == FAILURE) { - return; + RETURN_THROWS(); } REFLECTION_CHECK_VALID_GENERATOR(ex) @@ -2115,7 +2044,7 @@ ZEND_METHOD(reflection_generator, getExecutingLine) zend_execute_data *ex = generator->execute_data; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } REFLECTION_CHECK_VALID_GENERATOR(ex) @@ -2131,7 +2060,7 @@ ZEND_METHOD(reflection_generator, getExecutingFile) zend_execute_data *ex = generator->execute_data; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } REFLECTION_CHECK_VALID_GENERATOR(ex) @@ -2147,7 +2076,7 @@ ZEND_METHOD(reflection_generator, getFunction) zend_execute_data *ex = generator->execute_data; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } REFLECTION_CHECK_VALID_GENERATOR(ex) @@ -2171,7 +2100,7 @@ ZEND_METHOD(reflection_generator, getThis) zend_execute_data *ex = generator->execute_data; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } REFLECTION_CHECK_VALID_GENERATOR(ex) @@ -2193,7 +2122,7 @@ ZEND_METHOD(reflection_generator, getExecutingGenerator) zend_generator *current; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } REFLECTION_CHECK_VALID_GENERATOR(ex) @@ -2205,14 +2134,6 @@ ZEND_METHOD(reflection_generator, getExecutingGenerator) } /* }}} */ -/* {{{ proto public static mixed ReflectionParameter::export(mixed function, mixed parameter [, bool return]) throws ReflectionException - Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */ -ZEND_METHOD(reflection_parameter, export) -{ - _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_parameter_ptr, 2); -} -/* }}} */ - /* {{{ proto public void ReflectionParameter::__construct(mixed function, mixed parameter) Constructor. Throws an Exception in case the given method does not exist */ ZEND_METHOD(reflection_parameter, __construct) @@ -2229,8 +2150,8 @@ ZEND_METHOD(reflection_parameter, __construct) zend_class_entry *ce = NULL; zend_bool is_closure = 0; - if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "zz", &reference, ¶meter) == FAILURE) { - return; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &reference, ¶meter) == FAILURE) { + RETURN_THROWS(); } object = ZEND_THIS; @@ -2246,7 +2167,7 @@ ZEND_METHOD(reflection_parameter, __construct) if (!fptr) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Function %s() does not exist", Z_STRVAL_P(reference)); - return; + RETURN_THROWS(); } ce = fptr->common.scope; } @@ -2261,7 +2182,7 @@ ZEND_METHOD(reflection_parameter, __construct) || ((method = zend_hash_index_find(Z_ARRVAL_P(reference), 1)) == NULL)) { _DO_THROW("Expected array($object, $method) or array($classname, $method)"); - return; + RETURN_THROWS(); } if (Z_TYPE_P(classref) == IS_OBJECT) { @@ -2275,7 +2196,7 @@ ZEND_METHOD(reflection_parameter, __construct) zend_throw_exception_ex(reflection_exception_ptr, 0, "Class %s does not exist", ZSTR_VAL(name)); zend_string_release(name); - return; + RETURN_THROWS(); } zend_string_release(name); } @@ -2296,7 +2217,7 @@ ZEND_METHOD(reflection_parameter, __construct) zend_string_release(lcname); zend_throw_exception_ex(reflection_exception_ptr, 0, "Method %s::%s() does not exist", ZSTR_VAL(ce->name), Z_STRVAL_P(method)); - return; + RETURN_THROWS(); } zend_string_release(name); zend_string_release(lcname); @@ -2313,14 +2234,14 @@ ZEND_METHOD(reflection_parameter, __construct) } 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); - return; + RETURN_THROWS(); } } break; default: - _DO_THROW("The parameter class is expected to be either a string, an array(class, method) or a callable object"); - return; + zend_argument_error(reflection_exception_ptr, 1, "must be either a string, an array(class, method) or a callable object, %s given", zend_zval_type_name(reference)); + RETURN_THROWS(); } /* Now, search for the parameter */ @@ -2398,9 +2319,7 @@ ZEND_METHOD(reflection_parameter, __construct) failure: if (fptr->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) { - if (fptr->type != ZEND_OVERLOADED_FUNCTION) { - zend_string_release_ex(fptr->common.function_name, 0); - } + zend_string_release_ex(fptr->common.function_name, 0); zend_free_trampoline(fptr); } if (is_closure) { @@ -2418,7 +2337,7 @@ ZEND_METHOD(reflection_parameter, __toString) smart_str str = {0}; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); _parameter_string(&str, param->fptr, param->arg_info, param->offset, param->required, ""); @@ -2432,7 +2351,7 @@ ZEND_METHOD(reflection_parameter, __toString) ZEND_METHOD(reflection_parameter, getName) { if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } _default_get_name(ZEND_THIS, return_value); } @@ -2446,7 +2365,7 @@ ZEND_METHOD(reflection_parameter, getDeclaringFunction) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); @@ -2466,7 +2385,7 @@ ZEND_METHOD(reflection_parameter, getDeclaringClass) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); @@ -2485,11 +2404,12 @@ ZEND_METHOD(reflection_parameter, getClass) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); - if (ZEND_TYPE_IS_CLASS(param->arg_info->type)) { + // TODO: This is going to return null for union types, which is rather odd. + if (ZEND_TYPE_HAS_NAME(param->arg_info->type)) { /* Class name is stored as a string, we might also get "self" or "parent" * - For "self", simply use the function scope. If scope is NULL then * the function is global and thus self does not make any sense @@ -2510,19 +2430,19 @@ ZEND_METHOD(reflection_parameter, getClass) if (!ce) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Parameter uses 'self' as type hint but function is not a class member!"); - return; + RETURN_THROWS(); } } else if (0 == zend_binary_strcasecmp(ZSTR_VAL(class_name), ZSTR_LEN(class_name), "parent", sizeof("parent")- 1)) { ce = param->fptr->common.scope; if (!ce) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Parameter uses 'parent' as type hint but function is not a class member!"); - return; + RETURN_THROWS(); } if (!ce->parent) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Parameter uses 'parent' as type hint although class does not have a parent!"); - return; + RETURN_THROWS(); } ce = ce->parent; } else { @@ -2530,7 +2450,7 @@ ZEND_METHOD(reflection_parameter, getClass) if (!ce) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Class %s does not exist", ZSTR_VAL(class_name)); - return; + RETURN_THROWS(); } } zend_reflection_class_factory(ce, return_value); @@ -2546,7 +2466,7 @@ ZEND_METHOD(reflection_parameter, hasType) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); @@ -2562,14 +2482,14 @@ ZEND_METHOD(reflection_parameter, getType) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); if (!ZEND_TYPE_IS_SET(param->arg_info->type)) { RETURN_NULL(); } - reflection_type_factory(param->arg_info->type, return_value); + reflection_type_factory(param->arg_info->type, return_value, 1); } /* }}} */ @@ -2579,13 +2499,15 @@ ZEND_METHOD(reflection_parameter, isArray) { reflection_object *intern; parameter_reference *param; + uint32_t type_mask; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); - RETVAL_BOOL(ZEND_TYPE_CODE(param->arg_info->type) == IS_ARRAY); + type_mask = ZEND_TYPE_PURE_MASK_WITHOUT_NULL(param->arg_info->type); + RETVAL_BOOL(type_mask == MAY_BE_ARRAY); } /* }}} */ @@ -2595,13 +2517,15 @@ ZEND_METHOD(reflection_parameter, isCallable) { reflection_object *intern; parameter_reference *param; + uint32_t type_mask; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); - RETVAL_BOOL(ZEND_TYPE_CODE(param->arg_info->type) == IS_CALLABLE); + type_mask = ZEND_TYPE_PURE_MASK_WITHOUT_NULL(param->arg_info->type); + RETVAL_BOOL(type_mask == MAY_BE_CALLABLE); } /* }}} */ @@ -2613,11 +2537,12 @@ ZEND_METHOD(reflection_parameter, allowsNull) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); - RETVAL_BOOL(ZEND_TYPE_ALLOW_NULL(param->arg_info->type)); + RETVAL_BOOL(!ZEND_TYPE_IS_SET(param->arg_info->type) + || ZEND_TYPE_ALLOW_NULL(param->arg_info->type)); } /* }}} */ @@ -2629,11 +2554,11 @@ ZEND_METHOD(reflection_parameter, isPassedByReference) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); - RETVAL_BOOL(param->arg_info->pass_by_reference); + RETVAL_BOOL(ZEND_ARG_SEND_MODE(param->arg_info)); } /* }}} */ @@ -2645,12 +2570,12 @@ ZEND_METHOD(reflection_parameter, canBePassedByValue) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); /* true if it's ZEND_SEND_BY_VAL or ZEND_SEND_PREFER_REF */ - RETVAL_BOOL(param->arg_info->pass_by_reference != ZEND_SEND_BY_REF); + RETVAL_BOOL(ZEND_ARG_SEND_MODE(param->arg_info) != ZEND_SEND_BY_REF); } /* }}} */ @@ -2662,7 +2587,7 @@ ZEND_METHOD(reflection_parameter, getPosition) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); @@ -2678,7 +2603,7 @@ ZEND_METHOD(reflection_parameter, isOptional) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); @@ -2695,7 +2620,7 @@ ZEND_METHOD(reflection_parameter, isDefaultValueAvailable) zend_op *precv; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); @@ -2720,7 +2645,7 @@ ZEND_METHOD(reflection_parameter, getDefaultValue) zend_op *precv; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } param = _reflection_param_get_default_param(INTERNAL_FUNCTION_PARAM_PASSTHRU); @@ -2748,7 +2673,7 @@ ZEND_METHOD(reflection_parameter, isDefaultValueConstant) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } param = _reflection_param_get_default_param(INTERNAL_FUNCTION_PARAM_PASSTHRU); @@ -2778,7 +2703,7 @@ ZEND_METHOD(reflection_parameter, getDefaultValueConstantName) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } param = _reflection_param_get_default_param(INTERNAL_FUNCTION_PARAM_PASSTHRU); @@ -2807,11 +2732,11 @@ ZEND_METHOD(reflection_parameter, isVariadic) parameter_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); - RETVAL_BOOL(param->arg_info->is_variadic); + RETVAL_BOOL(ZEND_ARG_IS_VARIADIC(param->arg_info)); } /* }}} */ @@ -2823,7 +2748,7 @@ ZEND_METHOD(reflection_type, allowsNull) type_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); @@ -2831,72 +2756,132 @@ ZEND_METHOD(reflection_type, allowsNull) } /* }}} */ -/* {{{ proto public bool ReflectionType::isBuiltin() - Returns whether parameter is a builtin type */ -ZEND_METHOD(reflection_type, isBuiltin) +static zend_string *zend_type_to_string_without_null(zend_type type) { + ZEND_TYPE_FULL_MASK(type) &= ~MAY_BE_NULL; + return zend_type_to_string(type); +} + +/* {{{ proto public string ReflectionType::__toString() + Return the text of the type hint */ +ZEND_METHOD(reflection_type, __toString) { reflection_object *intern; type_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); - RETVAL_BOOL(ZEND_TYPE_IS_CODE(param->type)); + RETURN_STR(zend_type_to_string(param->type)); } /* }}} */ -/* {{{ reflection_type_name */ -static zend_string *reflection_type_name(type_reference *param) { - if (ZEND_TYPE_IS_NAME(param->type)) { - return zend_string_copy(ZEND_TYPE_NAME(param->type)); - } else if (ZEND_TYPE_IS_CE(param->type)) { - return zend_string_copy(ZEND_TYPE_CE(param->type)->name); - } else { - char *name = zend_get_type_by_const(ZEND_TYPE_CODE(param->type)); - return zend_string_init(name, strlen(name), 0); +/* {{{ proto public string ReflectionNamedType::getName() + Return the name of the type */ +ZEND_METHOD(reflection_named_type, getName) +{ + reflection_object *intern; + type_reference *param; + + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); } + GET_REFLECTION_OBJECT_PTR(param); + + if (param->legacy_behavior) { + RETURN_STR(zend_type_to_string_without_null(param->type)); + } + RETURN_STR(zend_type_to_string(param->type)); } /* }}} */ -/* {{{ proto public string ReflectionType::__toString() - Return the text of the type hint */ -ZEND_METHOD(reflection_type, __toString) +/* {{{ proto public bool ReflectionNamedType::isBuiltin() + Returns whether type is a builtin type */ +ZEND_METHOD(reflection_named_type, isBuiltin) { reflection_object *intern; type_reference *param; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); - RETURN_STR(reflection_type_name(param)); + /* Treat "static" as a class type for the purposes of reflection. */ + RETVAL_BOOL(ZEND_TYPE_IS_ONLY_MASK(param->type) + && !(ZEND_TYPE_FULL_MASK(param->type) & MAY_BE_STATIC)); } /* }}} */ -/* {{{ proto public string ReflectionNamedType::getName() - Return the text of the type hint */ -ZEND_METHOD(reflection_named_type, getName) +static void append_type(zval *return_value, zend_type type) { + zval reflection_type; + reflection_type_factory(type, &reflection_type, 0); + zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &reflection_type); +} + +static void append_type_mask(zval *return_value, uint32_t type_mask) { + append_type(return_value, (zend_type) ZEND_TYPE_INIT_MASK(type_mask)); +} + +/* {{{ proto public string ReflectionUnionType::getTypes() + Returns the types that are part of this union type */ +ZEND_METHOD(reflection_union_type, getTypes) { reflection_object *intern; type_reference *param; + uint32_t type_mask; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(param); - RETURN_STR(reflection_type_name(param)); -} -/* }}} */ + array_init(return_value); + if (ZEND_TYPE_HAS_LIST(param->type)) { + zend_type *list_type; + ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(param->type), list_type) { + append_type(return_value, *list_type); + } ZEND_TYPE_LIST_FOREACH_END(); + } else if (ZEND_TYPE_HAS_NAME(param->type)) { + append_type(return_value, + (zend_type) ZEND_TYPE_INIT_CLASS(ZEND_TYPE_NAME(param->type), 0, 0)); + } else if (ZEND_TYPE_HAS_CE(param->type)) { + append_type(return_value, + (zend_type) ZEND_TYPE_INIT_CE(ZEND_TYPE_CE(param->type), 0, 0)); + } -/* {{{ proto public static mixed ReflectionMethod::export(mixed class, string name [, bool return]) throws ReflectionException - Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */ -ZEND_METHOD(reflection_method, export) -{ - _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_method_ptr, 2); + type_mask = ZEND_TYPE_PURE_MASK(param->type); + ZEND_ASSERT(!(type_mask & MAY_BE_VOID)); + if (type_mask & MAY_BE_CALLABLE) { + append_type_mask(return_value, MAY_BE_CALLABLE); + } + if (type_mask & MAY_BE_ITERABLE) { + append_type_mask(return_value, MAY_BE_ITERABLE); + } + if (type_mask & MAY_BE_OBJECT) { + append_type_mask(return_value, MAY_BE_OBJECT); + } + if (type_mask & MAY_BE_ARRAY) { + append_type_mask(return_value, MAY_BE_ARRAY); + } + if (type_mask & MAY_BE_STRING) { + append_type_mask(return_value, MAY_BE_STRING); + } + if (type_mask & MAY_BE_LONG) { + append_type_mask(return_value, MAY_BE_LONG); + } + if (type_mask & MAY_BE_DOUBLE) { + append_type_mask(return_value, MAY_BE_DOUBLE); + } + if ((type_mask & MAY_BE_BOOL) == MAY_BE_BOOL) { + append_type_mask(return_value, MAY_BE_BOOL); + } else if (type_mask & MAY_BE_FALSE) { + append_type_mask(return_value, MAY_BE_FALSE); + } + if (type_mask & MAY_BE_NULL) { + append_type_mask(return_value, MAY_BE_NULL); + } } /* }}} */ @@ -2915,14 +2900,13 @@ ZEND_METHOD(reflection_method, __construct) zval ztmp; if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "zs", &classname, &name_str, &name_len) == FAILURE) { - if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) { - return; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) { + RETURN_THROWS(); } if ((tmp = strstr(name_str, "::")) == NULL) { - zend_throw_exception_ex(reflection_exception_ptr, 0, - "Invalid method name %s", name_str); - return; + zend_argument_error(reflection_exception_ptr, 1, "must be a valid method name"); + RETURN_THROWS(); } classname = &ztmp; tmp_len = tmp - name_str; @@ -2950,7 +2934,7 @@ ZEND_METHOD(reflection_method, __construct) if (classname == &ztmp) { zval_ptr_dtor_str(&ztmp); } - return; + RETURN_THROWS(); } break; @@ -2962,8 +2946,8 @@ ZEND_METHOD(reflection_method, __construct) if (classname == &ztmp) { zval_ptr_dtor_str(&ztmp); } - _DO_THROW("The parameter class is expected to be either a string or an object"); - return; + zend_argument_error(reflection_exception_ptr, 1, "must be of type object|string, %s given", zend_zval_type_name(classname)); + RETURN_THROWS(); } if (classname == &ztmp) { @@ -2981,7 +2965,7 @@ ZEND_METHOD(reflection_method, __construct) efree(lcname); zend_throw_exception_ex(reflection_exception_ptr, 0, "Method %s::%s() does not exist", ZSTR_VAL(ce->name), name_str); - return; + RETURN_THROWS(); } efree(lcname); @@ -3002,7 +2986,7 @@ ZEND_METHOD(reflection_method, __toString) smart_str str = {0}; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(mptr); _function_string(&str, mptr, intern->ce, ""); @@ -3024,12 +3008,12 @@ ZEND_METHOD(reflection_method, getClosure) zend_create_fake_closure(return_value, mptr, mptr->common.scope, mptr->common.scope, NULL); } else { if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &obj) == FAILURE) { - return; + RETURN_THROWS(); } if (!instanceof_function(Z_OBJCE_P(obj), mptr->common.scope)) { _DO_THROW("Given object is not an instance of the class this method was declared in"); - return; + RETURN_THROWS(); } /* This is an original closure object and __invoke is to be called. */ @@ -3064,7 +3048,7 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) 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)); - return; + RETURN_THROWS(); } if (!(mptr->common.fn_flags & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) { @@ -3073,16 +3057,16 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) mptr->common.fn_flags & ZEND_ACC_PROTECTED ? "protected" : "private", ZSTR_VAL(mptr->common.scope->name), ZSTR_VAL(mptr->common.function_name), ZSTR_VAL(Z_OBJCE_P(ZEND_THIS)->name)); - return; + RETURN_THROWS(); } if (variadic) { if (zend_parse_parameters(ZEND_NUM_ARGS(), "o!*", &object, ¶ms, &argc) == FAILURE) { - return; + RETURN_THROWS(); } } else { if (zend_parse_parameters(ZEND_NUM_ARGS(), "o!a", &object, ¶m_array) == FAILURE) { - return; + RETURN_THROWS(); } argc = zend_hash_num_elements(Z_ARRVAL_P(param_array)); @@ -3109,7 +3093,7 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) 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)); - return; + RETURN_THROWS(); } obj_ce = Z_OBJCE_P(object); @@ -3119,7 +3103,7 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) efree(params); } _DO_THROW("Given object is not an instance of the class this method was declared in"); - return; + RETURN_THROWS(); } } @@ -3154,7 +3138,7 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) if (result == FAILURE) { 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)); - return; + RETURN_THROWS(); } if (Z_TYPE(retval) != IS_UNDEF) { @@ -3166,7 +3150,7 @@ static void reflection_method_invoke(INTERNAL_FUNCTION_PARAMETERS, int variadic) } /* }}} */ -/* {{{ proto public mixed ReflectionMethod::invoke(mixed object, mixed* args) +/* {{{ proto public mixed ReflectionMethod::invoke(mixed object, [mixed* args]) Invokes the method. */ ZEND_METHOD(reflection_method, invoke) { @@ -3262,7 +3246,7 @@ ZEND_METHOD(reflection_function, inNamespace) const char *backslash; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } if ((name = _default_load_name(ZEND_THIS)) == NULL) { RETURN_FALSE; @@ -3285,7 +3269,7 @@ ZEND_METHOD(reflection_function, getNamespaceName) const char *backslash; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } if ((name = _default_load_name(ZEND_THIS)) == NULL) { RETURN_FALSE; @@ -3308,7 +3292,7 @@ ZEND_METHOD(reflection_function, getShortName) const char *backslash; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } if ((name = _default_load_name(ZEND_THIS)) == NULL) { RETURN_FALSE; @@ -3331,7 +3315,7 @@ ZEND_METHOD(reflection_function, hasReturnType) zend_function *fptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); @@ -3348,7 +3332,7 @@ ZEND_METHOD(reflection_function, getReturnType) zend_function *fptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(fptr); @@ -3357,7 +3341,7 @@ ZEND_METHOD(reflection_function, getReturnType) RETURN_NULL(); } - reflection_type_factory(fptr->common.arg_info[-1].type, return_value); + reflection_type_factory(fptr->common.arg_info[-1].type, return_value, 1); } /* }}} */ @@ -3369,7 +3353,7 @@ ZEND_METHOD(reflection_method, isConstructor) zend_function *mptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(mptr); /* we need to check if the ctor is the ctor of the class level we we @@ -3387,7 +3371,7 @@ ZEND_METHOD(reflection_method, isDestructor) zend_function *mptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(mptr); RETURN_BOOL(mptr->common.fn_flags & ZEND_ACC_DTOR); @@ -3404,7 +3388,7 @@ ZEND_METHOD(reflection_method, getModifiers) | ZEND_ACC_STATIC | ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(mptr); @@ -3422,7 +3406,7 @@ ZEND_METHOD(reflection_method, getDeclaringClass) GET_REFLECTION_OBJECT_PTR(mptr); if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } zend_reflection_class_factory(mptr->common.scope, return_value); @@ -3439,13 +3423,13 @@ ZEND_METHOD(reflection_method, getPrototype) GET_REFLECTION_OBJECT_PTR(mptr); if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } 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)); - return; + RETURN_THROWS(); } reflection_method_factory(mptr->common.prototype->common.scope, mptr->common.prototype, NULL, return_value); @@ -3460,7 +3444,7 @@ ZEND_METHOD(reflection_method, setAccessible) zend_bool visible; if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &visible) == FAILURE) { - return; + RETURN_THROWS(); } intern = Z_REFLECTION_P(ZEND_THIS); @@ -3479,8 +3463,8 @@ ZEND_METHOD(reflection_class_constant, __construct) zend_class_entry *ce; zend_class_constant *constant = NULL; - if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "zS", &classname, &constname) == FAILURE) { - return; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "zS", &classname, &constname) == FAILURE) { + RETURN_THROWS(); } object = ZEND_THIS; @@ -3492,7 +3476,7 @@ ZEND_METHOD(reflection_class_constant, __construct) if ((ce = zend_lookup_class(Z_STR_P(classname))) == NULL) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Class %s does not exist", Z_STRVAL_P(classname)); - return; + RETURN_THROWS(); } break; @@ -3501,13 +3485,13 @@ ZEND_METHOD(reflection_class_constant, __construct) break; default: - _DO_THROW("The parameter class is expected to be either a string or an object"); - return; + zend_argument_error(reflection_exception_ptr, 1, "must be of type object|string, %s given", zend_zval_type_name(classname)); + RETURN_THROWS(); } if ((constant = zend_hash_find_ptr(&ce->constants_table, constname)) == NULL) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Class Constant %s::%s does not exist", ZSTR_VAL(ce->name), ZSTR_VAL(constname)); - return; + RETURN_THROWS(); } intern->ptr = constant; @@ -3515,7 +3499,7 @@ ZEND_METHOD(reflection_class_constant, __construct) intern->ce = constant->ce; intern->ignore_visibility = 0; ZVAL_STR_COPY(reflection_prop_name(object), constname); - ZVAL_STR_COPY(reflection_prop_class(object), ce->name); + ZVAL_STR_COPY(reflection_prop_class(object), constant->ce->name); } /* }}} */ @@ -3529,7 +3513,7 @@ ZEND_METHOD(reflection_class_constant, __toString) zval name; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); _default_get_name(ZEND_THIS, &name); @@ -3544,7 +3528,7 @@ ZEND_METHOD(reflection_class_constant, __toString) ZEND_METHOD(reflection_class_constant, getName) { if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } _default_get_name(ZEND_THIS, return_value); } @@ -3556,7 +3540,7 @@ static void _class_constant_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) / zend_class_constant *ref; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); RETURN_BOOL(Z_ACCESS_FLAGS(ref->value) & mask); @@ -3595,7 +3579,7 @@ ZEND_METHOD(reflection_class_constant, getModifiers) zend_class_constant *ref; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); @@ -3611,7 +3595,7 @@ ZEND_METHOD(reflection_class_constant, getValue) zend_class_constant *ref; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); @@ -3630,7 +3614,7 @@ ZEND_METHOD(reflection_class_constant, getDeclaringClass) zend_class_constant *ref; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); @@ -3646,7 +3630,7 @@ ZEND_METHOD(reflection_class_constant, getDocComment) zend_class_constant *ref; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); if (ref->doc_comment) { @@ -3656,14 +3640,6 @@ ZEND_METHOD(reflection_class_constant, getDocComment) } /* }}} */ -/* {{{ proto public static mixed ReflectionClass::export(mixed argument [, bool return]) throws ReflectionException - Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */ -ZEND_METHOD(reflection_class, export) -{ - _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_class_ptr, 1); -} -/* }}} */ - /* {{{ reflection_class_object_ctor */ static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_object) { @@ -3693,14 +3669,14 @@ static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_ob } } else { if (!try_convert_to_string(argument)) { - return; + RETURN_THROWS(); } if ((ce = zend_lookup_class(Z_STR_P(argument))) == NULL) { if (!EG(exception)) { zend_throw_exception_ex(reflection_exception_ptr, -1, "Class %s does not exist", Z_STRVAL_P(argument)); } - return; + RETURN_THROWS(); } ZVAL_STR_COPY(reflection_prop_name(object), ce->name); @@ -3719,7 +3695,7 @@ ZEND_METHOD(reflection_class, __construct) /* }}} */ /* {{{ add_class_vars */ -static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value) +static void add_class_vars(zend_class_entry *ce, zend_bool statics, zval *return_value) { zend_property_info *prop_info; zval *prop, prop_copy; @@ -3732,14 +3708,14 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value prop_info->ce != ce)) { continue; } - prop = NULL; - if (statics && (prop_info->flags & ZEND_ACC_STATIC) != 0) { - prop = &ce->default_static_members_table[prop_info->offset]; - ZVAL_DEINDIRECT(prop); - } else if (!statics && (prop_info->flags & ZEND_ACC_STATIC) == 0) { - prop = &ce->default_properties_table[OBJ_PROP_TO_NUM(prop_info->offset)]; + + zend_bool is_static = (prop_info->flags & ZEND_ACC_STATIC) != 0; + if (statics != is_static) { + continue; } - if (!prop || (prop_info->type && Z_ISUNDEF_P(prop))) { + + prop = property_get_default(prop_info); + if (Z_ISUNDEF_P(prop)) { continue; } @@ -3768,7 +3744,7 @@ ZEND_METHOD(reflection_class, getStaticProperties) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -3792,7 +3768,7 @@ ZEND_METHOD(reflection_class, getStaticPropertyValue) zval *prop, *def_value = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|z", &name, &def_value) == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -3826,7 +3802,7 @@ ZEND_METHOD(reflection_class, setStaticPropertyValue) zval *variable_ptr, *value; if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz", &name, &value) == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -3839,7 +3815,7 @@ ZEND_METHOD(reflection_class, setStaticPropertyValue) 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)); - return; + RETURN_THROWS(); } if (Z_ISREF_P(variable_ptr)) { @@ -3851,7 +3827,7 @@ ZEND_METHOD(reflection_class, setStaticPropertyValue) } } - if (prop_info->type && !zend_verify_property_type(prop_info, value, 0)) { + if (ZEND_TYPE_IS_SET(prop_info->type) && !zend_verify_property_type(prop_info, value, 0)) { return; } @@ -3869,7 +3845,7 @@ ZEND_METHOD(reflection_class, getDefaultProperties) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); array_init(return_value); @@ -3890,7 +3866,7 @@ ZEND_METHOD(reflection_class, __toString) smart_str str = {0}; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); _class_string(&str, ce, &intern->obj, ""); @@ -3903,7 +3879,7 @@ ZEND_METHOD(reflection_class, __toString) ZEND_METHOD(reflection_class, getName) { if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } _default_get_name(ZEND_THIS, return_value); } @@ -3917,7 +3893,7 @@ ZEND_METHOD(reflection_class, isInternal) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); RETURN_BOOL(ce->type == ZEND_INTERNAL_CLASS); @@ -3932,7 +3908,7 @@ ZEND_METHOD(reflection_class, isUserDefined) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); RETURN_BOOL(ce->type == ZEND_USER_CLASS); @@ -3947,7 +3923,7 @@ ZEND_METHOD(reflection_class, isAnonymous) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); RETURN_BOOL(ce->ce_flags & ZEND_ACC_ANON_CLASS); @@ -3962,7 +3938,7 @@ ZEND_METHOD(reflection_class, getFileName) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); if (ce->type == ZEND_USER_CLASS) { @@ -3980,7 +3956,7 @@ ZEND_METHOD(reflection_class, getStartLine) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); if (ce->type == ZEND_USER_CLASS) { @@ -3998,7 +3974,7 @@ ZEND_METHOD(reflection_class, getEndLine) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); if (ce->type == ZEND_USER_CLASS) { @@ -4016,7 +3992,7 @@ ZEND_METHOD(reflection_class, getDocComment) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); if (ce->type == ZEND_USER_CLASS && ce->info.user.doc_comment) { @@ -4034,7 +4010,7 @@ ZEND_METHOD(reflection_class, getConstructor) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4055,7 +4031,7 @@ ZEND_METHOD(reflection_class, hasMethod) zend_string *name, *lc_name; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4076,7 +4052,7 @@ ZEND_METHOD(reflection_class, getMethod) zend_string *name, *lc_name; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4106,6 +4082,10 @@ ZEND_METHOD(reflection_class, getMethod) /* {{{ _addmethod */ static void _addmethod(zend_function *mptr, zend_class_entry *ce, zval *retval, zend_long filter) { + if ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) && mptr->common.scope != ce) { + return; + } + if (mptr->common.fn_flags & filter) { zval method; reflection_method_factory(ce, mptr, NULL, &method); @@ -4125,7 +4105,7 @@ ZEND_METHOD(reflection_class, getMethods) zend_bool filter_is_null = 1; if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l!", &filter, &filter_is_null) == FAILURE) { - return; + RETURN_THROWS(); } if (filter_is_null) { @@ -4168,10 +4148,9 @@ ZEND_METHOD(reflection_class, hasProperty) zend_property_info *property_info; zend_class_entry *ce; zend_string *name; - zval property; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4182,12 +4161,9 @@ ZEND_METHOD(reflection_class, hasProperty) RETURN_TRUE; } else { if (Z_TYPE(intern->obj) != IS_UNDEF) { - ZVAL_STR_COPY(&property, name); - if (Z_OBJ_HANDLER(intern->obj, has_property)(&intern->obj, &property, 2, NULL)) { - zval_ptr_dtor(&property); + if (Z_OBJ_HANDLER(intern->obj, has_property)(Z_OBJ(intern->obj), name, 2, NULL)) { RETURN_TRUE; } - zval_ptr_dtor(&property); } RETURN_FALSE; } @@ -4206,25 +4182,19 @@ ZEND_METHOD(reflection_class, getProperty) size_t classname_len, str_name_len; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); if ((property_info = zend_hash_find_ptr(&ce->properties_info, name)) != NULL) { if (!(property_info->flags & ZEND_ACC_PRIVATE) || property_info->ce == ce) { - reflection_property_factory(ce, name, property_info, return_value, 0); + reflection_property_factory(ce, name, property_info, return_value); return; } } else if (Z_TYPE(intern->obj) != IS_UNDEF) { /* Check for dynamic properties */ - if (zend_hash_exists(Z_OBJ_HT(intern->obj)->get_properties(&intern->obj), name)) { - zend_property_info property_info_tmp; - property_info_tmp.flags = ZEND_ACC_PUBLIC; - property_info_tmp.name = name; - property_info_tmp.doc_comment = NULL; - property_info_tmp.ce = ce; - - reflection_property_factory(ce, name, &property_info_tmp, return_value, 1); + if (zend_hash_exists(Z_OBJ_HT(intern->obj)->get_properties(Z_OBJ(intern->obj)), name)) { + reflection_property_factory(ce, name, NULL, return_value); return; } } @@ -4243,13 +4213,13 @@ ZEND_METHOD(reflection_class, getProperty) zend_throw_exception_ex(reflection_exception_ptr, -1, "Class %s does not exist", ZSTR_VAL(classname)); } zend_string_release_ex(classname, 0); - return; + RETURN_THROWS(); } 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)); - return; + RETURN_THROWS(); } ce = ce2; @@ -4275,7 +4245,7 @@ static void _addproperty(zend_property_info *pptr, zend_string *key, zend_class_ if (pptr->flags & filter) { zval property; - reflection_property_factory(ce, key, pptr, &property, 0); + reflection_property_factory(ce, key, pptr, &property); add_next_index_zval(retval, &property); } } @@ -4284,7 +4254,6 @@ static void _addproperty(zend_property_info *pptr, zend_string *key, zend_class_ /* {{{ _adddynproperty */ static void _adddynproperty(zval *ptr, zend_string *key, zend_class_entry *ce, zval *retval) { - zend_property_info property_info; zval property; /* under some circumstances, the properties hash table may contain numeric @@ -4299,12 +4268,7 @@ static void _adddynproperty(zval *ptr, zend_string *key, zend_class_entry *ce, z return; } - property_info.doc_comment = NULL; - property_info.flags = ZEND_ACC_PUBLIC; - property_info.name = key; - property_info.ce = ce; - property_info.offset = -1; - reflection_property_factory(ce, key, &property_info, &property, 1); + reflection_property_factory(ce, key, NULL, &property); add_next_index_zval(retval, &property); } /* }}} */ @@ -4321,7 +4285,7 @@ ZEND_METHOD(reflection_class, getProperties) zend_bool filter_is_null = 1; if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l!", &filter, &filter_is_null) == FAILURE) { - return; + RETURN_THROWS(); } if (filter_is_null) { @@ -4336,7 +4300,7 @@ ZEND_METHOD(reflection_class, getProperties) } ZEND_HASH_FOREACH_END(); if (Z_TYPE(intern->obj) != IS_UNDEF && (filter & ZEND_ACC_PUBLIC) != 0) { - HashTable *properties = Z_OBJ_HT(intern->obj)->get_properties(&intern->obj); + HashTable *properties = Z_OBJ_HT(intern->obj)->get_properties(Z_OBJ(intern->obj)); zval *prop; ZEND_HASH_FOREACH_STR_KEY_VAL(properties, key, prop) { _adddynproperty(prop, key, ce, return_value); @@ -4354,7 +4318,7 @@ ZEND_METHOD(reflection_class, hasConstant) zend_string *name; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4377,7 +4341,7 @@ ZEND_METHOD(reflection_class, getConstants) zval val; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); array_init(return_value); @@ -4402,13 +4366,13 @@ ZEND_METHOD(reflection_class, getReflectionConstants) zend_class_constant *constant; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); array_init(return_value); ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->constants_table, name, constant) { zval class_const; - reflection_class_constant_factory(ce, name, constant, &class_const); + reflection_class_constant_factory(name, constant, &class_const); zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &class_const); } ZEND_HASH_FOREACH_END(); } @@ -4424,7 +4388,7 @@ ZEND_METHOD(reflection_class, getConstant) zend_string *name; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4451,13 +4415,13 @@ ZEND_METHOD(reflection_class, getReflectionConstant) GET_REFLECTION_OBJECT_PTR(ce); if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) { - return; + RETURN_THROWS(); } if ((constant = zend_hash_find_ptr(&ce->constants_table, name)) == NULL) { RETURN_FALSE; } - reflection_class_constant_factory(ce, name, constant, return_value); + reflection_class_constant_factory(name, constant, return_value); } /* }}} */ @@ -4468,7 +4432,7 @@ static void _class_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); RETVAL_BOOL(ce->ce_flags & mask); @@ -4483,7 +4447,7 @@ ZEND_METHOD(reflection_class, isInstantiable) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); if (ce->ce_flags & (ZEND_ACC_INTERFACE | ZEND_ACC_TRAIT | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS | ZEND_ACC_IMPLICIT_ABSTRACT_CLASS)) { @@ -4509,7 +4473,7 @@ ZEND_METHOD(reflection_class, isCloneable) zval obj; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); if (ce->ce_flags & (ZEND_ACC_INTERFACE | ZEND_ACC_TRAIT | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS | ZEND_ACC_IMPLICIT_ABSTRACT_CLASS)) { @@ -4579,7 +4543,7 @@ ZEND_METHOD(reflection_class, getModifiers) | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4596,14 +4560,14 @@ ZEND_METHOD(reflection_class, isInstance) zval *object; if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &object) == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); RETURN_BOOL(instanceof_function(Z_OBJCE_P(object), ce)); } /* }}} */ -/* {{{ proto public object ReflectionClass::newInstance(mixed* args, ...) +/* {{{ proto public object ReflectionClass::newInstance([mixed* args], ...) Returns an instance of this class */ ZEND_METHOD(reflection_class, newInstance) { @@ -4638,7 +4602,7 @@ ZEND_METHOD(reflection_class, newInstance) if (zend_parse_parameters(ZEND_NUM_ARGS(), "*", ¶ms, &num_args) == FAILURE) { zval_ptr_dtor(return_value); - RETURN_FALSE; + RETURN_THROWS(); } for (i = 0; i < num_args; i++) { @@ -4686,10 +4650,14 @@ ZEND_METHOD(reflection_class, newInstanceWithoutConstructor) GET_REFLECTION_OBJECT_PTR(ce); + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + 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)); - return; + RETURN_THROWS(); } object_init_ex(return_value, ce); @@ -4710,7 +4678,7 @@ ZEND_METHOD(reflection_class, newInstanceArgs) GET_REFLECTION_OBJECT_PTR(ce); if (zend_parse_parameters(ZEND_NUM_ARGS(), "|h", &args) == FAILURE) { - return; + RETURN_THROWS(); } if (ZEND_NUM_ARGS() > 0) { @@ -4791,7 +4759,7 @@ ZEND_METHOD(reflection_class, getInterfaces) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4820,7 +4788,7 @@ ZEND_METHOD(reflection_class, getInterfaceNames) uint32_t i; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4847,7 +4815,7 @@ ZEND_METHOD(reflection_class, getTraits) uint32_t i; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4879,7 +4847,7 @@ ZEND_METHOD(reflection_class, getTraitNames) uint32_t i; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4903,7 +4871,7 @@ ZEND_METHOD(reflection_class, getTraitAliases) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4938,7 +4906,7 @@ ZEND_METHOD(reflection_class, getParentClass) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -4961,7 +4929,7 @@ ZEND_METHOD(reflection_class, isSubclassOf) GET_REFLECTION_OBJECT_PTR(ce); if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &class_name) == FAILURE) { - return; + RETURN_THROWS(); } switch (Z_TYPE_P(class_name)) { @@ -4969,7 +4937,7 @@ ZEND_METHOD(reflection_class, isSubclassOf) if ((class_ce = zend_lookup_class(Z_STR_P(class_name))) == NULL) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Class %s does not exist", Z_STRVAL_P(class_name)); - return; + RETURN_THROWS(); } break; case IS_OBJECT: @@ -4977,16 +4945,15 @@ ZEND_METHOD(reflection_class, isSubclassOf) argument = Z_REFLECTION_P(class_name); if (argument->ptr == NULL) { zend_throw_error(NULL, "Internal error: Failed to retrieve the argument's reflection object"); - return; + RETURN_THROWS(); } class_ce = argument->ptr; break; } /* no break */ default: - zend_throw_exception_ex(reflection_exception_ptr, 0, - "Parameter one must either be a string or a ReflectionClass object"); - return; + zend_argument_error(reflection_exception_ptr, 1, "must be of type ReflectionClass|string, %s given", zend_zval_type_name(class_name)); + RETURN_THROWS(); } RETURN_BOOL((ce != class_ce && instanceof_function(ce, class_ce))); @@ -5004,7 +4971,7 @@ ZEND_METHOD(reflection_class, implementsInterface) GET_REFLECTION_OBJECT_PTR(ce); if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &interface) == FAILURE) { - return; + RETURN_THROWS(); } switch (Z_TYPE_P(interface)) { @@ -5012,7 +4979,7 @@ ZEND_METHOD(reflection_class, implementsInterface) if ((interface_ce = zend_lookup_class(Z_STR_P(interface))) == NULL) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Interface %s does not exist", Z_STRVAL_P(interface)); - return; + RETURN_THROWS(); } break; case IS_OBJECT: @@ -5020,22 +4987,21 @@ ZEND_METHOD(reflection_class, implementsInterface) argument = Z_REFLECTION_P(interface); if (argument->ptr == NULL) { zend_throw_error(NULL, "Internal error: Failed to retrieve the argument's reflection object"); - return; + RETURN_THROWS(); } interface_ce = argument->ptr; break; } /* no break */ default: - zend_throw_exception_ex(reflection_exception_ptr, 0, - "Parameter one must either be a string or a ReflectionClass object"); - return; + zend_argument_error(reflection_exception_ptr, 1, "must be of type ReflectionClass|string, %s given", zend_zval_type_name(interface)); + RETURN_THROWS(); } 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)); - return; + RETURN_THROWS(); } RETURN_BOOL(instanceof_function(ce, interface_ce)); } @@ -5049,7 +5015,7 @@ ZEND_METHOD(reflection_class, isIterable) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -5071,7 +5037,7 @@ ZEND_METHOD(reflection_class, getExtension) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -5090,7 +5056,7 @@ ZEND_METHOD(reflection_class, getExtensionName) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ce); @@ -5111,7 +5077,7 @@ ZEND_METHOD(reflection_class, inNamespace) const char *backslash; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } if ((name = _default_load_name(ZEND_THIS)) == NULL) { RETURN_FALSE; @@ -5134,7 +5100,7 @@ ZEND_METHOD(reflection_class, getNamespaceName) const char *backslash; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } if ((name = _default_load_name(ZEND_THIS)) == NULL) { RETURN_FALSE; @@ -5157,7 +5123,7 @@ ZEND_METHOD(reflection_class, getShortName) const char *backslash; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } if ((name = _default_load_name(ZEND_THIS)) == NULL) { RETURN_FALSE; @@ -5172,14 +5138,6 @@ ZEND_METHOD(reflection_class, getShortName) } /* }}} */ -/* {{{ proto public static mixed ReflectionObject::export(mixed argument [, bool return]) throws ReflectionException - Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */ -ZEND_METHOD(reflection_object, export) -{ - _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_object_ptr, 1); -} -/* }}} */ - /* {{{ proto public void ReflectionObject::__construct(mixed argument) throws ReflectionException Constructor. Takes an instance as an argument */ ZEND_METHOD(reflection_object, __construct) @@ -5188,22 +5146,6 @@ ZEND_METHOD(reflection_object, __construct) } /* }}} */ -/* {{{ proto public static mixed ReflectionProperty::export(mixed class, string name [, bool return]) throws ReflectionException - Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */ -ZEND_METHOD(reflection_property, export) -{ - _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_property_ptr, 2); -} -/* }}} */ - -/* {{{ proto public static mixed ReflectionClassConstant::export(mixed class, string name [, bool return]) throws ReflectionException - Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */ -ZEND_METHOD(reflection_class_constant, export) -{ - _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_class_constant_ptr, 2); -} -/* }}} */ - /* {{{ proto public void ReflectionProperty::__construct(mixed class, string name) Constructor. Throws an Exception in case the given property does not exist */ ZEND_METHOD(reflection_property, __construct) @@ -5217,8 +5159,8 @@ ZEND_METHOD(reflection_property, __construct) zend_property_info *property_info = NULL; property_reference *reference; - if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "zS", &classname, &name) == FAILURE) { - return; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "zS", &classname, &name) == FAILURE) { + RETURN_THROWS(); } object = ZEND_THIS; @@ -5230,7 +5172,7 @@ ZEND_METHOD(reflection_property, __construct) if ((ce = zend_lookup_class(Z_STR_P(classname))) == NULL) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Class %s does not exist", Z_STRVAL_P(classname)); - return; + RETURN_THROWS(); } break; @@ -5239,8 +5181,8 @@ ZEND_METHOD(reflection_property, __construct) break; default: - _DO_THROW("The parameter class is expected to be either a string or an object"); - return; + zend_argument_error(reflection_exception_ptr, 1, "must be of type object|string, %s given", zend_zval_type_name(classname)); + RETURN_THROWS(); } property_info = zend_hash_find_ptr(&ce->properties_info, name); @@ -5249,25 +5191,13 @@ ZEND_METHOD(reflection_property, __construct) && property_info->ce != ce)) { /* Check for dynamic properties */ if (property_info == NULL && Z_TYPE_P(classname) == IS_OBJECT) { - if (zend_hash_exists(Z_OBJ_HT_P(classname)->get_properties(classname), name)) { + if (zend_hash_exists(Z_OBJ_HT_P(classname)->get_properties(Z_OBJ_P(classname)), name)) { dynam_prop = 1; } } 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)); - return; - } - } - - if (dynam_prop == 0 && (property_info->flags & ZEND_ACC_PRIVATE) == 0) { - /* we have to search the class hierarchy for this (implicit) public or protected property */ - zend_class_entry *tmp_ce = ce; - zend_property_info *tmp_info; - - while (tmp_ce && (tmp_info = zend_hash_find_ptr(&tmp_ce->properties_info, name)) == NULL) { - ce = tmp_ce; - property_info = tmp_info; - tmp_ce = tmp_ce->parent; + RETURN_THROWS(); } } @@ -5279,16 +5209,7 @@ ZEND_METHOD(reflection_property, __construct) } reference = (property_reference*) emalloc(sizeof(property_reference)); - if (dynam_prop) { - reference->prop.flags = ZEND_ACC_PUBLIC; - reference->prop.name = name; - reference->prop.doc_comment = NULL; - reference->prop.ce = ce; - reference->dynamic = 1; - } else { - reference->prop = *property_info; - reference->dynamic = 0; - } + reference->prop = dynam_prop ? NULL : property_info; reference->unmangled_name = zend_string_copy(name); intern->ptr = reference; intern->ref_type = REF_TYPE_PROPERTY; @@ -5306,10 +5227,10 @@ ZEND_METHOD(reflection_property, __toString) smart_str str = {0}; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); - _property_string(&str, &ref->prop, ZSTR_VAL(ref->unmangled_name), "", ref->dynamic); + _property_string(&str, ref->prop, ZSTR_VAL(ref->unmangled_name), ""); RETURN_STR(smart_str_extract(&str)); } /* }}} */ @@ -5319,7 +5240,7 @@ ZEND_METHOD(reflection_property, __toString) ZEND_METHOD(reflection_property, getName) { if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } _default_get_name(ZEND_THIS, return_value); } @@ -5331,10 +5252,10 @@ static void _property_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) /* {{{ property_reference *ref; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); - RETURN_BOOL(ref->prop.flags & mask); + RETURN_BOOL(prop_get_flags(ref) & mask); } /* }}} */ @@ -5378,10 +5299,10 @@ ZEND_METHOD(reflection_property, isDefault) property_reference *ref; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); - RETURN_BOOL(!ref->dynamic); + RETURN_BOOL(ref->prop != NULL); } /* }}} */ @@ -5394,11 +5315,11 @@ ZEND_METHOD(reflection_property, getModifiers) uint32_t keep_flags = ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); - RETURN_LONG((ref->prop.flags & keep_flags)); + RETURN_LONG(prop_get_flags(ref) & keep_flags); } /* }}} */ @@ -5408,19 +5329,23 @@ ZEND_METHOD(reflection_property, getValue) { reflection_object *intern; property_reference *ref; - zval *object, *name; + zval *object = NULL, *name; zval *member_p = NULL; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "|o!", &object) == FAILURE) { + RETURN_THROWS(); + } + GET_REFLECTION_OBJECT_PTR(ref); - if (!(ref->prop.flags & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) { + if (!(prop_get_flags(ref) & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) { name = _default_load_name(ZEND_THIS); zend_throw_exception_ex(reflection_exception_ptr, 0, "Cannot access non-public member %s::$%s", ZSTR_VAL(intern->ce->name), Z_STRVAL_P(name)); - return; + RETURN_THROWS(); } - if (ref->prop.flags & ZEND_ACC_STATIC) { + if (prop_get_flags(ref) & ZEND_ACC_STATIC) { member_p = zend_read_static_property_ex(intern->ce, ref->unmangled_name, 0); if (member_p) { ZVAL_COPY_DEREF(return_value, member_p); @@ -5428,13 +5353,15 @@ ZEND_METHOD(reflection_property, getValue) } else { zval rv; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &object) == FAILURE) { - return; + if (!object) { + zend_type_error("No object provided for getValue() on instance property"); + RETURN_THROWS(); } - if (!instanceof_function(Z_OBJCE_P(object), ref->prop.ce)) { + /* TODO: Should this always use intern->ce? */ + if (!instanceof_function(Z_OBJCE_P(object), ref->prop ? ref->prop->ce : intern->ce)) { _DO_THROW("Given object is not an instance of the class this property was declared in"); - return; + RETURN_THROWS(); } member_p = zend_read_property_ex(intern->ce, object, ref->unmangled_name, 0, &rv); @@ -5462,24 +5389,24 @@ ZEND_METHOD(reflection_property, setValue) GET_REFLECTION_OBJECT_PTR(ref); - if (!(ref->prop.flags & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) { + if (!(prop_get_flags(ref) & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) { name = _default_load_name(ZEND_THIS); zend_throw_exception_ex(reflection_exception_ptr, 0, "Cannot access non-public member %s::$%s", ZSTR_VAL(intern->ce->name), Z_STRVAL_P(name)); - return; + RETURN_THROWS(); } - if (ref->prop.flags & ZEND_ACC_STATIC) { + if (prop_get_flags(ref) & ZEND_ACC_STATIC) { if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "z", &value) == FAILURE) { if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &tmp, &value) == FAILURE) { - return; + RETURN_THROWS(); } } zend_update_static_property_ex(intern->ce, ref->unmangled_name, value); } else { if (zend_parse_parameters(ZEND_NUM_ARGS(), "oz", &object, &value) == FAILURE) { - return; + RETURN_THROWS(); } zend_update_property_ex(intern->ce, object, ref->unmangled_name, value); @@ -5493,42 +5420,46 @@ ZEND_METHOD(reflection_property, isInitialized) { reflection_object *intern; property_reference *ref; - zval *object, *name; + zval *object = NULL, *name; zval *member_p = NULL; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "|o!", &object) == FAILURE) { + RETURN_THROWS(); + } + GET_REFLECTION_OBJECT_PTR(ref); - if (!(ref->prop.flags & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) { + if (!(prop_get_flags(ref) & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) { name = _default_load_name(getThis()); zend_throw_exception_ex(reflection_exception_ptr, 0, "Cannot access non-public member %s::$%s", ZSTR_VAL(intern->ce->name), Z_STRVAL_P(name)); - return; + RETURN_THROWS(); } - if (ref->prop.flags & ZEND_ACC_STATIC) { + if (prop_get_flags(ref) & ZEND_ACC_STATIC) { member_p = zend_read_static_property_ex(intern->ce, ref->unmangled_name, 1); if (member_p) { - RETURN_BOOL(!Z_ISUNDEF_P(member_p)) + RETURN_BOOL(!Z_ISUNDEF_P(member_p)); } RETURN_FALSE; } else { - zval name_zv; zend_class_entry *old_scope; int retval; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &object) == FAILURE) { - return; + if (!object) { + zend_type_error("No object provided for isInitialized() on instance property"); + RETURN_THROWS(); } - if (!instanceof_function(Z_OBJCE_P(object), ref->prop.ce)) { + /* TODO: Should this always use intern->ce? */ + if (!instanceof_function(Z_OBJCE_P(object), ref->prop ? ref->prop->ce : intern->ce)) { _DO_THROW("Given object is not an instance of the class this property was declared in"); - return; + RETURN_THROWS(); } old_scope = EG(fake_scope); EG(fake_scope) = intern->ce; - ZVAL_STR(&name_zv, ref->unmangled_name); - retval = Z_OBJ_HT_P(object)->has_property(object, &name_zv, ZEND_PROPERTY_EXISTS, NULL); + retval = Z_OBJ_HT_P(object)->has_property(Z_OBJ_P(object), ref->unmangled_name, ZEND_PROPERTY_EXISTS, NULL); EG(fake_scope) = old_scope; RETVAL_BOOL(retval); @@ -5542,28 +5473,14 @@ ZEND_METHOD(reflection_property, getDeclaringClass) { reflection_object *intern; property_reference *ref; - zend_class_entry *tmp_ce, *ce; - zend_property_info *tmp_info; + zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); - ce = tmp_ce = intern->ce; - while (tmp_ce && (tmp_info = zend_hash_find_ptr(&tmp_ce->properties_info, ref->unmangled_name)) != NULL) { - if (tmp_info->flags & ZEND_ACC_PRIVATE) { - /* it's a private property, so it can't be inherited */ - break; - } - ce = tmp_ce; - if (tmp_ce == tmp_info->ce) { - /* declared in this class, done */ - break; - } - tmp_ce = tmp_ce->parent; - } - + ce = ref->prop ? ref->prop->ce : intern->ce; zend_reflection_class_factory(ce, return_value); } /* }}} */ @@ -5576,11 +5493,11 @@ ZEND_METHOD(reflection_property, getDocComment) property_reference *ref; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); - if (ref->prop.doc_comment) { - RETURN_STR_COPY(ref->prop.doc_comment); + if (ref->prop && ref->prop->doc_comment) { + RETURN_STR_COPY(ref->prop->doc_comment); } RETURN_FALSE; } @@ -5594,7 +5511,7 @@ ZEND_METHOD(reflection_property, setAccessible) zend_bool visible; if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &visible) == FAILURE) { - return; + RETURN_THROWS(); } intern = Z_REFLECTION_P(ZEND_THIS); @@ -5611,16 +5528,16 @@ ZEND_METHOD(reflection_property, getType) property_reference *ref; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); - if (!ZEND_TYPE_IS_SET(ref->prop.type)) { + if (!ref->prop || !ZEND_TYPE_IS_SET(ref->prop->type)) { RETURN_NULL(); } - reflection_type_factory(ref->prop.type, return_value); + reflection_type_factory(ref->prop->type, return_value, 1); } /* }}} */ @@ -5632,20 +5549,78 @@ ZEND_METHOD(reflection_property, hasType) property_reference *ref; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(ref); - RETVAL_BOOL(ZEND_TYPE_IS_SET(ref->prop.type)); + RETVAL_BOOL(ref->prop && ZEND_TYPE_IS_SET(ref->prop->type)); } /* }}} */ -/* {{{ proto public static mixed ReflectionExtension::export(string name [, bool return]) throws ReflectionException - Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */ -ZEND_METHOD(reflection_extension, export) +/* {{{ proto public bool ReflectionProperty::hasDefaultValue() + Returns whether property has a default value */ +ZEND_METHOD(reflection_property, hasDefaultValue) { - _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_extension_ptr, 1); + reflection_object *intern; + property_reference *ref; + zend_property_info *prop_info; + zval *prop; + + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + + GET_REFLECTION_OBJECT_PTR(ref); + + prop_info = ref->prop; + + if (prop_info == NULL) { + RETURN_FALSE; + } + + prop = property_get_default(prop_info); + RETURN_BOOL(!Z_ISUNDEF_P(prop)); +} +/* }}} */ + +/* {{{ proto public mixed ReflectionProperty::getDefaultValue() + Returns the default value of a property */ +ZEND_METHOD(reflection_property, getDefaultValue) +{ + reflection_object *intern; + property_reference *ref; + zend_property_info *prop_info; + zval *prop; + + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + + GET_REFLECTION_OBJECT_PTR(ref); + + prop_info = ref->prop; + + if (prop_info == NULL) { + return; // throw exception? + } + + prop = property_get_default(prop_info); + if (Z_ISUNDEF_P(prop)) { + return; + } + + /* copy: enforce read only access */ + ZVAL_DEREF(prop); + ZVAL_COPY_OR_DUP(return_value, prop); + + /* this is necessary to make it able to work with default array + * properties, returned to user */ + if (Z_TYPE_P(return_value) == IS_CONSTANT_AST) { + if (UNEXPECTED(zval_update_constant_ex(return_value, prop_info->ce) != SUCCESS)) { + RETURN_THROWS(); + } + } } /* }}} */ @@ -5661,8 +5636,8 @@ ZEND_METHOD(reflection_extension, __construct) size_t name_len; ALLOCA_FLAG(use_heap) - if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) { - return; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) { + RETURN_THROWS(); } object = ZEND_THIS; @@ -5673,7 +5648,7 @@ ZEND_METHOD(reflection_extension, __construct) free_alloca(lcname, use_heap); zend_throw_exception_ex(reflection_exception_ptr, 0, "Extension %s does not exist", name_str); - return; + RETURN_THROWS(); } free_alloca(lcname, use_heap); ZVAL_STRING(reflection_prop_name(object), module->name); @@ -5692,7 +5667,7 @@ ZEND_METHOD(reflection_extension, __toString) smart_str str = {0}; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(module); _extension_string(&str, module, ""); @@ -5705,7 +5680,7 @@ ZEND_METHOD(reflection_extension, __toString) ZEND_METHOD(reflection_extension, getName) { if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } _default_get_name(ZEND_THIS, return_value); } @@ -5719,7 +5694,7 @@ ZEND_METHOD(reflection_extension, getVersion) zend_module_entry *module; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(module); @@ -5742,7 +5717,7 @@ ZEND_METHOD(reflection_extension, getFunctions) zend_function *fptr; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(module); @@ -5766,7 +5741,7 @@ ZEND_METHOD(reflection_extension, getConstants) zend_constant *constant; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(module); @@ -5805,7 +5780,7 @@ ZEND_METHOD(reflection_extension, getINIEntries) zend_ini_entry *ini_entry; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(module); @@ -5850,7 +5825,7 @@ ZEND_METHOD(reflection_extension, getClasses) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(module); @@ -5871,7 +5846,7 @@ ZEND_METHOD(reflection_extension, getClassNames) zend_class_entry *ce; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(module); @@ -5891,7 +5866,7 @@ ZEND_METHOD(reflection_extension, getDependencies) const zend_module_dep *dep; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(module); @@ -5956,7 +5931,7 @@ ZEND_METHOD(reflection_extension, info) zend_module_entry *module; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(module); @@ -5972,7 +5947,7 @@ ZEND_METHOD(reflection_extension, isPersistent) zend_module_entry *module; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(module); @@ -5988,7 +5963,7 @@ ZEND_METHOD(reflection_extension, isTemporary) zend_module_entry *module; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(module); @@ -5996,14 +5971,6 @@ ZEND_METHOD(reflection_extension, isTemporary) } /* }}} */ -/* {{{ proto public static mixed ReflectionZendExtension::export(string name [, bool return]) throws ReflectionException - * Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */ -ZEND_METHOD(reflection_zend_extension, export) -{ - _reflection_export(INTERNAL_FUNCTION_PARAM_PASSTHRU, reflection_zend_extension_ptr, 1); -} -/* }}} */ - /* {{{ proto public void ReflectionZendExtension::__construct(string name) Constructor. Throws an Exception in case the given Zend extension does not exist */ ZEND_METHOD(reflection_zend_extension, __construct) @@ -6014,8 +5981,8 @@ ZEND_METHOD(reflection_zend_extension, __construct) char *name_str; size_t name_len; - if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) { - return; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) { + RETURN_THROWS(); } object = ZEND_THIS; @@ -6025,7 +5992,7 @@ ZEND_METHOD(reflection_zend_extension, __construct) if (!extension) { zend_throw_exception_ex(reflection_exception_ptr, 0, "Zend Extension %s does not exist", name_str); - return; + RETURN_THROWS(); } ZVAL_STRING(reflection_prop_name(object), extension->name); intern->ptr = extension; @@ -6043,7 +6010,7 @@ ZEND_METHOD(reflection_zend_extension, __toString) smart_str str = {0}; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(extension); _zend_extension_string(&str, extension, ""); @@ -6059,7 +6026,7 @@ ZEND_METHOD(reflection_zend_extension, getName) zend_extension *extension; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(extension); @@ -6075,7 +6042,7 @@ ZEND_METHOD(reflection_zend_extension, getVersion) zend_extension *extension; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(extension); @@ -6095,7 +6062,7 @@ ZEND_METHOD(reflection_zend_extension, getAuthor) zend_extension *extension; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(extension); @@ -6115,7 +6082,7 @@ ZEND_METHOD(reflection_zend_extension, getURL) zend_extension *extension; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(extension); @@ -6135,7 +6102,7 @@ ZEND_METHOD(reflection_zend_extension, getCopyright) zend_extension *extension; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } GET_REFLECTION_OBJECT_PTR(extension); @@ -6176,8 +6143,8 @@ ZEND_METHOD(reflection_reference, fromArrayElement) zval *key, *item; reflection_object *intern; - if (zend_parse_parameters_throw(ZEND_NUM_ARGS(), "hz", &ht, &key) == FAILURE) { - return; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "hz", &ht, &key) == FAILURE) { + RETURN_THROWS(); } if (Z_TYPE_P(key) == IS_LONG) { @@ -6185,13 +6152,13 @@ ZEND_METHOD(reflection_reference, fromArrayElement) } else if (Z_TYPE_P(key) == IS_STRING) { item = zend_symtable_find(ht, Z_STR_P(key)); } else { - zend_type_error("Key must be array or string"); - return; + zend_argument_type_error(2, "must be of type string|int, %s given", zend_zval_type_name(key)); + RETURN_THROWS(); } if (!item) { _DO_THROW("Array key not found"); - return; + RETURN_THROWS(); } if (Z_TYPE_P(item) != IS_REFERENCE || is_ignorable_reference(ht, item)) { @@ -6215,18 +6182,18 @@ ZEND_METHOD(reflection_reference, getId) PHP_SHA1_CTX context; if (zend_parse_parameters_none() == FAILURE) { - return; + RETURN_THROWS(); } intern = Z_REFLECTION_P(getThis()); if (Z_TYPE(intern->obj) != IS_REFERENCE) { _DO_THROW("Corrupted ReflectionReference object"); - return; + RETURN_THROWS(); } if (!REFLECTION_G(key_initialized)) { if (php_random_bytes_throw(&REFLECTION_G(key_initialized), 16) == FAILURE) { - return; + RETURN_THROWS(); } REFLECTION_G(key_initialized) = 1; @@ -6247,493 +6214,268 @@ static const zend_function_entry reflection_exception_functions[] = { PHP_FE_END }; -ZEND_BEGIN_ARG_INFO(arginfo_reflection__void, 0) -ZEND_END_ARG_INFO() - - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_getModifierNames, 0) - ZEND_ARG_INFO(0, modifiers) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_export, 0, 0, 1) - ZEND_ARG_OBJ_INFO(0, reflector, Reflector, 0) - ZEND_ARG_INFO(0, return) -ZEND_END_ARG_INFO() - static const zend_function_entry reflection_functions[] = { - ZEND_ME(reflection, getModifierNames, arginfo_reflection_getModifierNames, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) - ZEND_DEP_ME(reflection, export, arginfo_reflection_export, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + ZEND_ME(reflection, getModifierNames, arginfo_class_Reflection_getModifierNames, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) PHP_FE_END }; static const zend_function_entry reflector_functions[] = { - ZEND_ABSTRACT_ME(reflector, __toString, arginfo_reflection__void) PHP_FE_END }; -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_function_export, 0, 0, 1) - ZEND_ARG_INFO(0, name) - ZEND_ARG_INFO(0, return) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_function___construct, 0) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_function_invoke, 0, 0, 0) - ZEND_ARG_INFO(0, args) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_function_invokeArgs, 0) - ZEND_ARG_ARRAY_INFO(0, args, 0) -ZEND_END_ARG_INFO() - static const zend_function_entry reflection_function_abstract_functions[] = { - ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) - ZEND_ME(reflection_function, inNamespace, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, isClosure, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, isDeprecated, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, isInternal, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, isUserDefined, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, isGenerator, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, isVariadic, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getClosureThis, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getClosureScopeClass, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getDocComment, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getEndLine, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getExtension, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getExtensionName, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getFileName, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getName, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getNamespaceName, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getNumberOfParameters, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getNumberOfRequiredParameters, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getParameters, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getShortName, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getStartLine, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getStaticVariables, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, returnsReference, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, hasReturnType, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, getReturnType, arginfo_reflection__void, 0) + ZEND_ME(reflection, __clone, arginfo_class_ReflectionFunctionAbstract___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) + ZEND_ME(reflection_function, inNamespace, arginfo_class_ReflectionFunctionAbstract_inNamespace, 0) + ZEND_ME(reflection_function, isClosure, arginfo_class_ReflectionFunctionAbstract_isClosure, 0) + ZEND_ME(reflection_function, isDeprecated, arginfo_class_ReflectionFunctionAbstract_isDeprecated, 0) + ZEND_ME(reflection_function, isInternal, arginfo_class_ReflectionFunctionAbstract_isInternal, 0) + ZEND_ME(reflection_function, isUserDefined, arginfo_class_ReflectionFunctionAbstract_isUserDefined, 0) + ZEND_ME(reflection_function, isGenerator, arginfo_class_ReflectionFunctionAbstract_isGenerator, 0) + ZEND_ME(reflection_function, isVariadic, arginfo_class_ReflectionFunctionAbstract_isVariadic, 0) + ZEND_ME(reflection_function, getClosureThis, arginfo_class_ReflectionFunctionAbstract_getClosureThis, 0) + ZEND_ME(reflection_function, getClosureScopeClass, arginfo_class_ReflectionFunctionAbstract_getClosureScopeClass, 0) + ZEND_ME(reflection_function, getDocComment, arginfo_class_ReflectionFunctionAbstract_getDocComment, 0) + ZEND_ME(reflection_function, getEndLine, arginfo_class_ReflectionFunctionAbstract_getEndLine, 0) + ZEND_ME(reflection_function, getExtension, arginfo_class_ReflectionFunctionAbstract_getExtension, 0) + ZEND_ME(reflection_function, getExtensionName, arginfo_class_ReflectionFunctionAbstract_getExtensionName, 0) + ZEND_ME(reflection_function, getFileName, arginfo_class_ReflectionFunctionAbstract_getFileName, 0) + ZEND_ME(reflection_function, getName, arginfo_class_ReflectionFunctionAbstract_getName, 0) + ZEND_ME(reflection_function, getNamespaceName, arginfo_class_ReflectionFunctionAbstract_getNamespaceName, 0) + ZEND_ME(reflection_function, getNumberOfParameters, arginfo_class_ReflectionFunctionAbstract_getNumberOfParameters, 0) + ZEND_ME(reflection_function, getNumberOfRequiredParameters, arginfo_class_ReflectionFunctionAbstract_getNumberOfRequiredParameters, 0) + ZEND_ME(reflection_function, getParameters, arginfo_class_ReflectionFunctionAbstract_getParameters, 0) + ZEND_ME(reflection_function, getShortName, arginfo_class_ReflectionFunctionAbstract_getShortName, 0) + ZEND_ME(reflection_function, getStartLine, arginfo_class_ReflectionFunctionAbstract_getStartLine, 0) + ZEND_ME(reflection_function, getStaticVariables, arginfo_class_ReflectionFunctionAbstract_getStaticVariables, 0) + ZEND_ME(reflection_function, returnsReference, arginfo_class_ReflectionFunctionAbstract_returnsReference, 0) + ZEND_ME(reflection_function, hasReturnType, arginfo_class_ReflectionFunctionAbstract_hasReturnType, 0) + ZEND_ME(reflection_function, getReturnType, arginfo_class_ReflectionFunctionAbstract_getReturnType, 0) PHP_FE_END }; static const zend_function_entry reflection_function_functions[] = { - ZEND_ME(reflection_function, __construct, arginfo_reflection_function___construct, 0) - ZEND_ME(reflection_function, __toString, arginfo_reflection__void, 0) - ZEND_DEP_ME(reflection_function, export, arginfo_reflection_function_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) - ZEND_ME(reflection_function, isDisabled, arginfo_reflection__void, 0) - ZEND_ME(reflection_function, invoke, arginfo_reflection_function_invoke, 0) - ZEND_ME(reflection_function, invokeArgs, arginfo_reflection_function_invokeArgs, 0) - ZEND_ME(reflection_function, getClosure, arginfo_reflection__void, 0) + ZEND_ME(reflection_function, __construct, arginfo_class_ReflectionFunction___construct, 0) + ZEND_ME(reflection_function, __toString, arginfo_class_ReflectionFunction___toString, 0) + ZEND_ME(reflection_function, isDisabled, arginfo_class_ReflectionFunction_isDisabled, 0) + ZEND_ME(reflection_function, invoke, arginfo_class_ReflectionFunction_invoke, 0) + ZEND_ME(reflection_function, invokeArgs, arginfo_class_ReflectionFunction_invokeArgs, 0) + ZEND_ME(reflection_function, getClosure, arginfo_class_ReflectionFunction_getClosure, 0) PHP_FE_END }; -ZEND_BEGIN_ARG_INFO(arginfo_reflection_generator___construct, 0) - ZEND_ARG_INFO(0, generator) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_generator_trace, 0, 0, 0) - ZEND_ARG_INFO(0, options) -ZEND_END_ARG_INFO() - static const zend_function_entry reflection_generator_functions[] = { - ZEND_ME(reflection_generator, __construct, arginfo_reflection_generator___construct, 0) - ZEND_ME(reflection_generator, getExecutingLine, arginfo_reflection__void, 0) - ZEND_ME(reflection_generator, getExecutingFile, arginfo_reflection__void, 0) - ZEND_ME(reflection_generator, getTrace, arginfo_reflection_generator_trace, 0) - ZEND_ME(reflection_generator, getFunction, arginfo_reflection__void, 0) - ZEND_ME(reflection_generator, getThis, arginfo_reflection__void, 0) - ZEND_ME(reflection_generator, getExecutingGenerator, arginfo_reflection__void, 0) + ZEND_ME(reflection_generator, __construct, arginfo_class_ReflectionGenerator___construct, 0) + ZEND_ME(reflection_generator, getExecutingLine, arginfo_class_ReflectionGenerator_getExecutingLine, 0) + ZEND_ME(reflection_generator, getExecutingFile, arginfo_class_ReflectionGenerator_getExecutingFile, 0) + ZEND_ME(reflection_generator, getTrace, arginfo_class_ReflectionGenerator_getTrace, 0) + ZEND_ME(reflection_generator, getFunction, arginfo_class_ReflectionGenerator_getFunction, 0) + ZEND_ME(reflection_generator, getThis, arginfo_class_ReflectionGenerator_getThis, 0) + ZEND_ME(reflection_generator, getExecutingGenerator, arginfo_class_ReflectionGenerator_getExecutingGenerator, 0) PHP_FE_END }; -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_method_export, 0, 0, 2) - ZEND_ARG_INFO(0, class) - ZEND_ARG_INFO(0, name) - ZEND_ARG_INFO(0, return) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_method___construct, 0, 0, 1) - ZEND_ARG_INFO(0, class_or_method) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_method_invoke, 0) - ZEND_ARG_INFO(0, object) - ZEND_ARG_INFO(0, args) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_method_invokeArgs, 0) - ZEND_ARG_INFO(0, object) - ZEND_ARG_ARRAY_INFO(0, args, 0) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_method_setAccessible, 0) - ZEND_ARG_INFO(0, value) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_method_getClosure, 0, 0, 0) - ZEND_ARG_INFO(0, object) -ZEND_END_ARG_INFO() - static const zend_function_entry reflection_method_functions[] = { - ZEND_DEP_ME(reflection_method, export, arginfo_reflection_method_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) - ZEND_ME(reflection_method, __construct, arginfo_reflection_method___construct, 0) - ZEND_ME(reflection_method, __toString, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, isPublic, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, isPrivate, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, isProtected, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, isAbstract, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, isFinal, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, isStatic, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, isConstructor, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, isDestructor, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, getClosure, arginfo_reflection_method_getClosure, 0) - ZEND_ME(reflection_method, getModifiers, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, invoke, arginfo_reflection_method_invoke, 0) - ZEND_ME(reflection_method, invokeArgs, arginfo_reflection_method_invokeArgs, 0) - ZEND_ME(reflection_method, getDeclaringClass, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, getPrototype, arginfo_reflection__void, 0) - ZEND_ME(reflection_method, setAccessible, arginfo_reflection_method_setAccessible, 0) + ZEND_ME(reflection_method, __construct, arginfo_class_ReflectionMethod___construct, 0) + ZEND_ME(reflection_method, __toString, arginfo_class_ReflectionMethod___toString, 0) + ZEND_ME(reflection_method, isPublic, arginfo_class_ReflectionMethod_isPublic, 0) + ZEND_ME(reflection_method, isPrivate, arginfo_class_ReflectionMethod_isPrivate, 0) + ZEND_ME(reflection_method, isProtected, arginfo_class_ReflectionMethod_isProtected, 0) + ZEND_ME(reflection_method, isAbstract, arginfo_class_ReflectionMethod_isAbstract, 0) + ZEND_ME(reflection_method, isFinal, arginfo_class_ReflectionMethod_isFinal, 0) + ZEND_ME(reflection_method, isStatic, arginfo_class_ReflectionMethod_isStatic, 0) + ZEND_ME(reflection_method, isConstructor, arginfo_class_ReflectionMethod_isConstructor, 0) + ZEND_ME(reflection_method, isDestructor, arginfo_class_ReflectionMethod_isDestructor, 0) + ZEND_ME(reflection_method, getClosure, arginfo_class_ReflectionMethod_getClosure, 0) + ZEND_ME(reflection_method, getModifiers, arginfo_class_ReflectionMethod_getModifiers, 0) + ZEND_ME(reflection_method, invoke, arginfo_class_ReflectionMethod_invoke, 0) + ZEND_ME(reflection_method, invokeArgs, arginfo_class_ReflectionMethod_invokeArgs, 0) + ZEND_ME(reflection_method, getDeclaringClass, arginfo_class_ReflectionMethod_getDeclaringClass, 0) + ZEND_ME(reflection_method, getPrototype, arginfo_class_ReflectionMethod_getPrototype, 0) + ZEND_ME(reflection_method, setAccessible, arginfo_class_ReflectionMethod_setAccessible, 0) PHP_FE_END }; - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_export, 0, 0, 1) - ZEND_ARG_INFO(0, argument) - ZEND_ARG_INFO(0, return) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class___construct, 0) - ZEND_ARG_INFO(0, argument) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_getStaticPropertyValue, 0, 0, 1) - ZEND_ARG_INFO(0, name) - ZEND_ARG_INFO(0, default) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_setStaticPropertyValue, 0) - ZEND_ARG_INFO(0, name) - ZEND_ARG_INFO(0, value) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_hasMethod, 0) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_getMethod, 0) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_getMethods, 0, 0, 0) - ZEND_ARG_INFO(0, filter) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_hasProperty, 0) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_getProperty, 0) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_getProperties, 0, 0, 0) - ZEND_ARG_INFO(0, filter) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_hasConstant, 0) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_getConstant, 0) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_isInstance, 0) - ZEND_ARG_INFO(0, object) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_newInstance, 0) - ZEND_ARG_INFO(0, args) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_newInstanceWithoutConstructor, 0) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_newInstanceArgs, 0, 0, 0) - ZEND_ARG_ARRAY_INFO(0, args, 0) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_isSubclassOf, 0) - ZEND_ARG_INFO(0, class) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_implementsInterface, 0) - ZEND_ARG_INFO(0, interface) -ZEND_END_ARG_INFO() - static const zend_function_entry reflection_class_functions[] = { - ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) - ZEND_DEP_ME(reflection_class, export, arginfo_reflection_class_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) - ZEND_ME(reflection_class, __construct, arginfo_reflection_class___construct, 0) - ZEND_ME(reflection_class, __toString, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getName, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isInternal, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isUserDefined, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isAnonymous, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isInstantiable, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isCloneable, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getFileName, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getStartLine, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getEndLine, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getDocComment, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getConstructor, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, hasMethod, arginfo_reflection_class_hasMethod, 0) - ZEND_ME(reflection_class, getMethod, arginfo_reflection_class_getMethod, 0) - ZEND_ME(reflection_class, getMethods, arginfo_reflection_class_getMethods, 0) - ZEND_ME(reflection_class, hasProperty, arginfo_reflection_class_hasProperty, 0) - ZEND_ME(reflection_class, getProperty, arginfo_reflection_class_getProperty, 0) - ZEND_ME(reflection_class, getProperties, arginfo_reflection_class_getProperties, 0) - ZEND_ME(reflection_class, hasConstant, arginfo_reflection_class_hasConstant, 0) - ZEND_ME(reflection_class, getConstants, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getReflectionConstants, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getConstant, arginfo_reflection_class_getConstant, 0) - ZEND_ME(reflection_class, getReflectionConstant, arginfo_reflection_class_getConstant, 0) - ZEND_ME(reflection_class, getInterfaces, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getInterfaceNames, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isInterface, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getTraits, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getTraitNames, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getTraitAliases, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isTrait, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isAbstract, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isFinal, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getModifiers, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isInstance, arginfo_reflection_class_isInstance, 0) - ZEND_ME(reflection_class, newInstance, arginfo_reflection_class_newInstance, 0) - ZEND_ME(reflection_class, newInstanceWithoutConstructor, arginfo_reflection_class_newInstanceWithoutConstructor, 0) - ZEND_ME(reflection_class, newInstanceArgs, arginfo_reflection_class_newInstanceArgs, 0) - ZEND_ME(reflection_class, getParentClass, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isSubclassOf, arginfo_reflection_class_isSubclassOf, 0) - ZEND_ME(reflection_class, getStaticProperties, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getStaticPropertyValue, arginfo_reflection_class_getStaticPropertyValue, 0) - ZEND_ME(reflection_class, setStaticPropertyValue, arginfo_reflection_class_setStaticPropertyValue, 0) - ZEND_ME(reflection_class, getDefaultProperties, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, isIterable, arginfo_reflection__void, 0) - ZEND_MALIAS(reflection_class, isIterateable, isIterable, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, implementsInterface, arginfo_reflection_class_implementsInterface, 0) - ZEND_ME(reflection_class, getExtension, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getExtensionName, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, inNamespace, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getNamespaceName, arginfo_reflection__void, 0) - ZEND_ME(reflection_class, getShortName, arginfo_reflection__void, 0) + ZEND_ME(reflection, __clone, arginfo_class_ReflectionClass___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) + ZEND_ME(reflection_class, __construct, arginfo_class_ReflectionClass___construct, 0) + ZEND_ME(reflection_class, __toString, arginfo_class_ReflectionClass___toString, 0) + ZEND_ME(reflection_class, getName, arginfo_class_ReflectionClass_getName, 0) + ZEND_ME(reflection_class, isInternal, arginfo_class_ReflectionClass_isInternal, 0) + ZEND_ME(reflection_class, isUserDefined, arginfo_class_ReflectionClass_isUserDefined, 0) + ZEND_ME(reflection_class, isAnonymous, arginfo_class_ReflectionClass_isAnonymous, 0) + ZEND_ME(reflection_class, isInstantiable, arginfo_class_ReflectionClass_isInstantiable, 0) + ZEND_ME(reflection_class, isCloneable, arginfo_class_ReflectionClass_isCloneable, 0) + ZEND_ME(reflection_class, getFileName, arginfo_class_ReflectionClass_getFileName, 0) + ZEND_ME(reflection_class, getStartLine, arginfo_class_ReflectionClass_getStartLine, 0) + ZEND_ME(reflection_class, getEndLine, arginfo_class_ReflectionClass_getEndLine, 0) + ZEND_ME(reflection_class, getDocComment, arginfo_class_ReflectionClass_getDocComment, 0) + ZEND_ME(reflection_class, getConstructor, arginfo_class_ReflectionClass_getConstructor, 0) + ZEND_ME(reflection_class, hasMethod, arginfo_class_ReflectionClass_hasMethod, 0) + ZEND_ME(reflection_class, getMethod, arginfo_class_ReflectionClass_getMethod, 0) + ZEND_ME(reflection_class, getMethods, arginfo_class_ReflectionClass_getMethods, 0) + ZEND_ME(reflection_class, hasProperty, arginfo_class_ReflectionClass_hasProperty, 0) + ZEND_ME(reflection_class, getProperty, arginfo_class_ReflectionClass_getProperty, 0) + ZEND_ME(reflection_class, getProperties, arginfo_class_ReflectionClass_getProperties, 0) + ZEND_ME(reflection_class, hasConstant, arginfo_class_ReflectionClass_hasConstant, 0) + ZEND_ME(reflection_class, getConstants, arginfo_class_ReflectionClass_getConstants, 0) + ZEND_ME(reflection_class, getReflectionConstants, arginfo_class_ReflectionClass_getReflectionConstants, 0) + ZEND_ME(reflection_class, getConstant, arginfo_class_ReflectionClass_getConstant, 0) + ZEND_ME(reflection_class, getReflectionConstant, arginfo_class_ReflectionClass_getReflectionConstant, 0) + ZEND_ME(reflection_class, getInterfaces, arginfo_class_ReflectionClass_getInterfaces, 0) + ZEND_ME(reflection_class, getInterfaceNames, arginfo_class_ReflectionClass_getInterfaceNames, 0) + ZEND_ME(reflection_class, isInterface, arginfo_class_ReflectionClass_isInterface, 0) + ZEND_ME(reflection_class, getTraits, arginfo_class_ReflectionClass_getTraits, 0) + ZEND_ME(reflection_class, getTraitNames, arginfo_class_ReflectionClass_getTraitNames, 0) + ZEND_ME(reflection_class, getTraitAliases, arginfo_class_ReflectionClass_getTraitAliases, 0) + ZEND_ME(reflection_class, isTrait, arginfo_class_ReflectionClass_isTrait, 0) + ZEND_ME(reflection_class, isAbstract, arginfo_class_ReflectionClass_isAbstract, 0) + ZEND_ME(reflection_class, isFinal, arginfo_class_ReflectionClass_isFinal, 0) + ZEND_ME(reflection_class, getModifiers, arginfo_class_ReflectionClass_getModifiers, 0) + ZEND_ME(reflection_class, isInstance, arginfo_class_ReflectionClass_isIntance, 0) + ZEND_ME(reflection_class, newInstance, arginfo_class_ReflectionClass_newInstance, 0) + ZEND_ME(reflection_class, newInstanceWithoutConstructor, arginfo_class_ReflectionClass_newInstanceWithoutConstructor, 0) + ZEND_ME(reflection_class, newInstanceArgs, arginfo_class_ReflectionClass_newInstanceArgs, 0) + ZEND_ME(reflection_class, getParentClass, arginfo_class_ReflectionClass_getParentClass, 0) + ZEND_ME(reflection_class, isSubclassOf, arginfo_class_ReflectionClass_isSubclassOf, 0) + ZEND_ME(reflection_class, getStaticProperties, arginfo_class_ReflectionClass_getStaticProperties, 0) + ZEND_ME(reflection_class, getStaticPropertyValue, arginfo_class_ReflectionClass_getStaticPropertyValue, 0) + ZEND_ME(reflection_class, setStaticPropertyValue, arginfo_class_ReflectionClass_setStaticPropertyValue, 0) + ZEND_ME(reflection_class, getDefaultProperties, arginfo_class_ReflectionClass_getDefaultProperties, 0) + ZEND_ME(reflection_class, isIterable, arginfo_class_ReflectionClass_isIterable, 0) + ZEND_MALIAS(reflection_class, isIterateable, isIterable, arginfo_class_ReflectionClass_isIterateable, 0) + ZEND_ME(reflection_class, implementsInterface, arginfo_class_ReflectionClass_implementsInterface, 0) + ZEND_ME(reflection_class, getExtension, arginfo_class_ReflectionClass_getExtension, 0) + ZEND_ME(reflection_class, getExtensionName, arginfo_class_ReflectionClass_getExtensionName, 0) + ZEND_ME(reflection_class, inNamespace, arginfo_class_ReflectionClass_inNamespace, 0) + ZEND_ME(reflection_class, getNamespaceName, arginfo_class_ReflectionClass_getNamespaceName, 0) + ZEND_ME(reflection_class, getShortName, arginfo_class_ReflectionClass_getShortName, 0) PHP_FE_END }; - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_object_export, 0, 0, 1) - ZEND_ARG_INFO(0, argument) - ZEND_ARG_INFO(0, return) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_object___construct, 0) - ZEND_ARG_INFO(0, argument) -ZEND_END_ARG_INFO() - static const zend_function_entry reflection_object_functions[] = { - ZEND_DEP_ME(reflection_object, export, arginfo_reflection_object_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) - ZEND_ME(reflection_object, __construct, arginfo_reflection_object___construct, 0) + ZEND_ME(reflection_object, __construct, arginfo_class_ReflectionObject___construct, 0) PHP_FE_END }; - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_property_export, 0, 0, 2) - ZEND_ARG_INFO(0, class) - ZEND_ARG_INFO(0, name) - ZEND_ARG_INFO(0, return) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_property___construct, 0, 0, 2) - ZEND_ARG_INFO(0, class) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_property_getValue, 0, 0, 0) - ZEND_ARG_INFO(0, object) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_property_setValue, 0, 0, 1) - ZEND_ARG_INFO(0, object) - ZEND_ARG_INFO(0, value) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_property_isInitialized, 0, 0, 0) - ZEND_ARG_INFO(0, object) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_property_setAccessible, 0) - ZEND_ARG_INFO(0, visible) -ZEND_END_ARG_INFO() - static const zend_function_entry reflection_property_functions[] = { - ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) - ZEND_DEP_ME(reflection_property, export, arginfo_reflection_property_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) - ZEND_ME(reflection_property, __construct, arginfo_reflection_property___construct, 0) - ZEND_ME(reflection_property, __toString, arginfo_reflection__void, 0) - ZEND_ME(reflection_property, getName, arginfo_reflection__void, 0) - ZEND_ME(reflection_property, getValue, arginfo_reflection_property_getValue, 0) - ZEND_ME(reflection_property, setValue, arginfo_reflection_property_setValue, 0) - ZEND_ME(reflection_property, isInitialized, arginfo_reflection_property_isInitialized, 0) - ZEND_ME(reflection_property, isPublic, arginfo_reflection__void, 0) - ZEND_ME(reflection_property, isPrivate, arginfo_reflection__void, 0) - ZEND_ME(reflection_property, isProtected, arginfo_reflection__void, 0) - ZEND_ME(reflection_property, isStatic, arginfo_reflection__void, 0) - ZEND_ME(reflection_property, isDefault, arginfo_reflection__void, 0) - ZEND_ME(reflection_property, getModifiers, arginfo_reflection__void, 0) - ZEND_ME(reflection_property, getDeclaringClass, arginfo_reflection__void, 0) - ZEND_ME(reflection_property, getDocComment, arginfo_reflection__void, 0) - ZEND_ME(reflection_property, setAccessible, arginfo_reflection_property_setAccessible, 0) - ZEND_ME(reflection_property, getType, arginfo_reflection__void, 0) - ZEND_ME(reflection_property, hasType, arginfo_reflection__void, 0) + ZEND_ME(reflection, __clone, arginfo_class_ReflectionProperty___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) + ZEND_ME(reflection_property, __construct, arginfo_class_ReflectionProperty___construct, 0) + ZEND_ME(reflection_property, __toString, arginfo_class_ReflectionProperty___toString, 0) + ZEND_ME(reflection_property, getName, arginfo_class_ReflectionProperty_getName, 0) + ZEND_ME(reflection_property, getValue, arginfo_class_ReflectionProperty_getValue, 0) + ZEND_ME(reflection_property, setValue, arginfo_class_ReflectionProperty_setValue, 0) + ZEND_ME(reflection_property, isInitialized, arginfo_class_ReflectionProperty_isInitialized, 0) + ZEND_ME(reflection_property, isPublic, arginfo_class_ReflectionProperty_isPublic, 0) + ZEND_ME(reflection_property, isPrivate, arginfo_class_ReflectionProperty_isPrivate, 0) + ZEND_ME(reflection_property, isProtected, arginfo_class_ReflectionProperty_isProtected, 0) + ZEND_ME(reflection_property, isStatic, arginfo_class_ReflectionProperty_isStatic, 0) + ZEND_ME(reflection_property, isDefault, arginfo_class_ReflectionProperty_isDefault, 0) + ZEND_ME(reflection_property, getModifiers, arginfo_class_ReflectionProperty_getModifiers, 0) + ZEND_ME(reflection_property, getDeclaringClass, arginfo_class_ReflectionProperty_getDeclaringClass, 0) + ZEND_ME(reflection_property, getDocComment, arginfo_class_ReflectionProperty_getDocComment, 0) + ZEND_ME(reflection_property, setAccessible, arginfo_class_ReflectionProperty_setAccessible, 0) + ZEND_ME(reflection_property, getType, arginfo_class_ReflectionProperty_getType, 0) + ZEND_ME(reflection_property, hasType, arginfo_class_ReflectionProperty_hasType, 0) + ZEND_ME(reflection_property, hasDefaultValue, arginfo_class_ReflectionProperty_hasDefaultValue, 0) + ZEND_ME(reflection_property, getDefaultValue, arginfo_class_ReflectionProperty_getDefaultValue, 0) PHP_FE_END }; -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_constant_export, 0, 0, 2) - ZEND_ARG_INFO(0, class) - ZEND_ARG_INFO(0, name) - ZEND_ARG_INFO(0, return) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_class_constant___construct, 0, 0, 2) - ZEND_ARG_INFO(0, class) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() - static const zend_function_entry reflection_class_constant_functions[] = { - ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) - ZEND_DEP_ME(reflection_class_constant, export, arginfo_reflection_class_constant_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) - ZEND_ME(reflection_class_constant, __construct, arginfo_reflection_class_constant___construct, 0) - ZEND_ME(reflection_class_constant, __toString, arginfo_reflection__void, 0) - ZEND_ME(reflection_class_constant, getName, arginfo_reflection__void, 0) - ZEND_ME(reflection_class_constant, getValue, arginfo_reflection__void, 0) - ZEND_ME(reflection_class_constant, isPublic, arginfo_reflection__void, 0) - ZEND_ME(reflection_class_constant, isPrivate, arginfo_reflection__void, 0) - ZEND_ME(reflection_class_constant, isProtected, arginfo_reflection__void, 0) - ZEND_ME(reflection_class_constant, getModifiers, arginfo_reflection__void, 0) - ZEND_ME(reflection_class_constant, getDeclaringClass, arginfo_reflection__void, 0) - ZEND_ME(reflection_class_constant, getDocComment, arginfo_reflection__void, 0) + ZEND_ME(reflection, __clone, arginfo_class_ReflectionClassConstant___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) + ZEND_ME(reflection_class_constant, __construct, arginfo_class_ReflectionClassConstant___construct, 0) + ZEND_ME(reflection_class_constant, __toString, arginfo_class_ReflectionClassConstant___toString, 0) + ZEND_ME(reflection_class_constant, getName, arginfo_class_ReflectionClassConstant_getName, 0) + ZEND_ME(reflection_class_constant, getValue, arginfo_class_ReflectionClassConstant_getValue, 0) + ZEND_ME(reflection_class_constant, isPublic, arginfo_class_ReflectionClassConstant_isPublic, 0) + ZEND_ME(reflection_class_constant, isPrivate, arginfo_class_ReflectionClassConstant_isPrivate, 0) + ZEND_ME(reflection_class_constant, isProtected, arginfo_class_ReflectionClassConstant_isProtected, 0) + ZEND_ME(reflection_class_constant, getModifiers, arginfo_class_ReflectionClassConstant_getModifiers, 0) + ZEND_ME(reflection_class_constant, getDeclaringClass, arginfo_class_ReflectionClassConstant_getDeclaringClass, 0) + ZEND_ME(reflection_class_constant, getDocComment, arginfo_class_ReflectionClassConstant_getDocComment, 0) PHP_FE_END }; -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_parameter_export, 0, 0, 2) - ZEND_ARG_INFO(0, function) - ZEND_ARG_INFO(0, parameter) - ZEND_ARG_INFO(0, return) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_parameter___construct, 0) - ZEND_ARG_INFO(0, function) - ZEND_ARG_INFO(0, parameter) -ZEND_END_ARG_INFO() - static const zend_function_entry reflection_parameter_functions[] = { - ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) - ZEND_DEP_ME(reflection_parameter, export, arginfo_reflection_parameter_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) - ZEND_ME(reflection_parameter, __construct, arginfo_reflection_parameter___construct, 0) - ZEND_ME(reflection_parameter, __toString, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, getName, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, isPassedByReference, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, canBePassedByValue, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, getDeclaringFunction, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, getDeclaringClass, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, getClass, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, hasType, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, getType, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, isArray, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, isCallable, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, allowsNull, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, getPosition, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, isOptional, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, isDefaultValueAvailable, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, getDefaultValue, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, isDefaultValueConstant, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, getDefaultValueConstantName, arginfo_reflection__void, 0) - ZEND_ME(reflection_parameter, isVariadic, arginfo_reflection__void, 0) + ZEND_ME(reflection, __clone, arginfo_class_ReflectionParameter___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) + ZEND_ME(reflection_parameter, __construct, arginfo_class_ReflectionParameter___construct, 0) + ZEND_ME(reflection_parameter, __toString, arginfo_class_ReflectionParameter___toString, 0) + ZEND_ME(reflection_parameter, getName, arginfo_class_ReflectionParameter_getName, 0) + ZEND_ME(reflection_parameter, isPassedByReference, arginfo_class_ReflectionParameter_isPassedByReference, 0) + ZEND_ME(reflection_parameter, canBePassedByValue, arginfo_class_ReflectionParameter_canBePassedByValue, 0) + ZEND_ME(reflection_parameter, getDeclaringFunction, arginfo_class_ReflectionParameter_getDeclaringFunction, 0) + ZEND_ME(reflection_parameter, getDeclaringClass, arginfo_class_ReflectionParameter_getDeclaringClass, 0) + ZEND_ME(reflection_parameter, getClass, arginfo_class_ReflectionParameter_getClass, 0) + ZEND_ME(reflection_parameter, hasType, arginfo_class_ReflectionParameter_hasType, 0) + ZEND_ME(reflection_parameter, getType, arginfo_class_ReflectionParameter_getType, 0) + ZEND_ME(reflection_parameter, isArray, arginfo_class_ReflectionParameter_isArray, 0) + ZEND_ME(reflection_parameter, isCallable, arginfo_class_ReflectionParameter_isCallable, 0) + ZEND_ME(reflection_parameter, allowsNull, arginfo_class_ReflectionParameter_allowsNull, 0) + ZEND_ME(reflection_parameter, getPosition, arginfo_class_ReflectionParameter_getPosition, 0) + ZEND_ME(reflection_parameter, isOptional, arginfo_class_ReflectionParameter_isOptional, 0) + ZEND_ME(reflection_parameter, isDefaultValueAvailable, arginfo_class_ReflectionParameter_isDefaultValueAvailable, 0) + ZEND_ME(reflection_parameter, getDefaultValue, arginfo_class_ReflectionParameter_getDefaultValue, 0) + ZEND_ME(reflection_parameter, isDefaultValueConstant, arginfo_class_ReflectionParameter_isDefaultValueConstant, 0) + ZEND_ME(reflection_parameter, getDefaultValueConstantName, arginfo_class_ReflectionParameter_getDefaultValueConstantName, 0) + ZEND_ME(reflection_parameter, isVariadic, arginfo_class_ReflectionParameter_isVariadic, 0) PHP_FE_END }; static const zend_function_entry reflection_type_functions[] = { - ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) - ZEND_ME(reflection_type, allowsNull, arginfo_reflection__void, 0) - ZEND_ME(reflection_type, isBuiltin, arginfo_reflection__void, 0) - ZEND_ME(reflection_type, __toString, arginfo_reflection__void, ZEND_ACC_DEPRECATED) + ZEND_ME(reflection, __clone, arginfo_class_ReflectionType___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) + ZEND_ME(reflection_type, allowsNull, arginfo_class_ReflectionType_allowsNull, 0) + ZEND_ME(reflection_type, __toString, arginfo_class_ReflectionType___toString, 0) PHP_FE_END }; static const zend_function_entry reflection_named_type_functions[] = { - ZEND_ME(reflection_named_type, getName, arginfo_reflection__void, 0) + ZEND_ME(reflection_named_type, getName, arginfo_class_ReflectionNamedType_getName, 0) + ZEND_ME(reflection_named_type, isBuiltin, arginfo_class_ReflectionNamedType_isBuiltin, 0) PHP_FE_END }; -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_extension_export, 0, 0, 1) - ZEND_ARG_INFO(0, name) - ZEND_ARG_INFO(0, return) -ZEND_END_ARG_INFO() - -ZEND_BEGIN_ARG_INFO(arginfo_reflection_extension___construct, 0) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() +static const zend_function_entry reflection_union_type_functions[] = { + ZEND_ME(reflection_union_type, getTypes, arginfo_class_ReflectionUnionType_getTypes, 0) + PHP_FE_END +}; static const zend_function_entry reflection_extension_functions[] = { - ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) - ZEND_DEP_ME(reflection_extension, export, arginfo_reflection_extension_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) - ZEND_ME(reflection_extension, __construct, arginfo_reflection_extension___construct, 0) - ZEND_ME(reflection_extension, __toString, arginfo_reflection__void, 0) - ZEND_ME(reflection_extension, getName, arginfo_reflection__void, 0) - ZEND_ME(reflection_extension, getVersion, arginfo_reflection__void, 0) - ZEND_ME(reflection_extension, getFunctions, arginfo_reflection__void, 0) - ZEND_ME(reflection_extension, getConstants, arginfo_reflection__void, 0) - ZEND_ME(reflection_extension, getINIEntries, arginfo_reflection__void, 0) - ZEND_ME(reflection_extension, getClasses, arginfo_reflection__void, 0) - ZEND_ME(reflection_extension, getClassNames, arginfo_reflection__void, 0) - ZEND_ME(reflection_extension, getDependencies, arginfo_reflection__void, 0) - ZEND_ME(reflection_extension, info, arginfo_reflection__void, 0) - ZEND_ME(reflection_extension, isPersistent, arginfo_reflection__void, 0) - ZEND_ME(reflection_extension, isTemporary, arginfo_reflection__void, 0) + ZEND_ME(reflection, __clone, arginfo_class_ReflectionExtension___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) + ZEND_ME(reflection_extension, __construct, arginfo_class_ReflectionExtension___construct, 0) + ZEND_ME(reflection_extension, __toString, arginfo_class_ReflectionExtension___toString, 0) + ZEND_ME(reflection_extension, getName, arginfo_class_ReflectionExtension_getName, 0) + ZEND_ME(reflection_extension, getVersion, arginfo_class_ReflectionExtension_getVersion, 0) + ZEND_ME(reflection_extension, getFunctions, arginfo_class_ReflectionExtension_getFunctions, 0) + ZEND_ME(reflection_extension, getConstants, arginfo_class_ReflectionExtension_getConstants, 0) + ZEND_ME(reflection_extension, getINIEntries, arginfo_class_ReflectionExtension_getINIEntries, 0) + ZEND_ME(reflection_extension, getClasses, arginfo_class_ReflectionExtension_getClasses, 0) + ZEND_ME(reflection_extension, getClassNames, arginfo_class_ReflectionExtension_getClassNames, 0) + ZEND_ME(reflection_extension, getDependencies, arginfo_class_ReflectionExtension_getDependencies, 0) + ZEND_ME(reflection_extension, info, arginfo_class_ReflectionExtension_info, 0) + ZEND_ME(reflection_extension, isPersistent, arginfo_class_ReflectionExtension_isPersistent, 0) + ZEND_ME(reflection_extension, isTemporary, arginfo_class_ReflectionExtension_isTemporary, 0) PHP_FE_END }; -ZEND_BEGIN_ARG_INFO(arginfo_reflection_zend_extension___construct, 0) - ZEND_ARG_INFO(0, name) -ZEND_END_ARG_INFO() - static const zend_function_entry reflection_zend_extension_functions[] = { - ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) - ZEND_DEP_ME(reflection_zend_extension, export, arginfo_reflection_extension_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) - ZEND_ME(reflection_zend_extension, __construct, arginfo_reflection_zend_extension___construct, 0) - ZEND_ME(reflection_zend_extension, __toString, arginfo_reflection__void, 0) - ZEND_ME(reflection_zend_extension, getName, arginfo_reflection__void, 0) - ZEND_ME(reflection_zend_extension, getVersion, arginfo_reflection__void, 0) - ZEND_ME(reflection_zend_extension, getAuthor, arginfo_reflection__void, 0) - ZEND_ME(reflection_zend_extension, getURL, arginfo_reflection__void, 0) - ZEND_ME(reflection_zend_extension, getCopyright, arginfo_reflection__void, 0) + ZEND_ME(reflection, __clone, arginfo_class_ReflectionZendExtension___clone, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) + ZEND_ME(reflection_zend_extension, __construct, arginfo_class_ReflectionZendExtension___construct, 0) + ZEND_ME(reflection_zend_extension, __toString, arginfo_class_ReflectionZendExtension___toString, 0) + ZEND_ME(reflection_zend_extension, getName, arginfo_class_ReflectionZendExtension_getName, 0) + ZEND_ME(reflection_zend_extension, getVersion, arginfo_class_ReflectionZendExtension_getVersion, 0) + ZEND_ME(reflection_zend_extension, getAuthor, arginfo_class_ReflectionZendExtension_getAuthor, 0) + ZEND_ME(reflection_zend_extension, getURL, arginfo_class_ReflectionZendExtension_getURL, 0) + ZEND_ME(reflection_zend_extension, getCopyright, arginfo_class_ReflectionZendExtension_getCopyright, 0) PHP_FE_END }; -ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_reference_fromArrayElement, 0, 0, 2) - ZEND_ARG_INFO(0, array) - ZEND_ARG_INFO(0, key) -ZEND_END_ARG_INFO() - static const zend_function_entry reflection_reference_functions[] = { - ZEND_ME(reflection_reference, fromArrayElement, arginfo_reflection_reference_fromArrayElement, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) - ZEND_ME(reflection_reference, getId, arginfo_reflection__void, ZEND_ACC_PUBLIC) + ZEND_ME(reflection_reference, fromArrayElement, arginfo_class_ReflectionReference_fromArrayElement, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + ZEND_ME(reflection_reference, getId, arginfo_class_ReflectionReference_getId, ZEND_ACC_PUBLIC) /* Always throwing dummy methods */ - ZEND_ME(reflection, __clone, arginfo_reflection__void, ZEND_ACC_PRIVATE) - ZEND_ME(reflection_reference, __construct, arginfo_reflection__void, ZEND_ACC_PRIVATE) + ZEND_ME(reflection, __clone, arginfo_class_ReflectionReference___clone, ZEND_ACC_PRIVATE) + ZEND_ME(reflection_reference, __construct, arginfo_class_ReflectionReference___construct, ZEND_ACC_PRIVATE) PHP_FE_END }; /* }}} */ @@ -6743,20 +6485,19 @@ static const zend_function_entry reflection_ext_functions[] = { /* {{{ */ }; /* }}} */ /* {{{ _reflection_write_property */ -static zval *_reflection_write_property(zval *object, zval *member, zval *value, void **cache_slot) +static zval *_reflection_write_property(zend_object *object, zend_string *name, zval *value, void **cache_slot) { - if ((Z_TYPE_P(member) == IS_STRING) - && zend_hash_exists(&Z_OBJCE_P(object)->properties_info, Z_STR_P(member)) - && ((Z_STRLEN_P(member) == sizeof("name") - 1 && !memcmp(Z_STRVAL_P(member), "name", sizeof("name"))) - || (Z_STRLEN_P(member) == sizeof("class") - 1 && !memcmp(Z_STRVAL_P(member), "class", sizeof("class"))))) + if (zend_hash_exists(&object->ce->properties_info, name) + && ((ZSTR_LEN(name) == sizeof("name") - 1 && !memcmp(ZSTR_VAL(name), "name", sizeof("name"))) + || (ZSTR_LEN(name) == sizeof("class") - 1 && !memcmp(ZSTR_VAL(name), "class", sizeof("class"))))) { zend_throw_exception_ex(reflection_exception_ptr, 0, - "Cannot set read-only property %s::$%s", ZSTR_VAL(Z_OBJCE_P(object)->name), Z_STRVAL_P(member)); + "Cannot set read-only property %s::$%s", ZSTR_VAL(object->ce->name), ZSTR_VAL(name)); return &EG(uninitialized_zval); } else { - return zend_std_write_property(object, member, value, cache_slot); + return zend_std_write_property(object, name, value, cache_slot); } } /* }}} */ @@ -6786,6 +6527,7 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ INIT_CLASS_ENTRY(_reflection_entry, "Reflector", reflector_functions); reflector_ptr = zend_register_internal_interface(&_reflection_entry); + zend_class_implements(reflector_ptr, 1, zend_ce_stringable); INIT_CLASS_ENTRY(_reflection_entry, "ReflectionFunctionAbstract", reflection_function_abstract_functions); reflection_init_class_handlers(&_reflection_entry); @@ -6813,11 +6555,17 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ INIT_CLASS_ENTRY(_reflection_entry, "ReflectionType", reflection_type_functions); reflection_init_class_handlers(&_reflection_entry); reflection_type_ptr = zend_register_internal_class(&_reflection_entry); + reflection_type_ptr->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; + zend_class_implements(reflection_type_ptr, 1, zend_ce_stringable); INIT_CLASS_ENTRY(_reflection_entry, "ReflectionNamedType", reflection_named_type_functions); reflection_init_class_handlers(&_reflection_entry); reflection_named_type_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_type_ptr); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionUnionType", reflection_union_type_functions); + reflection_init_class_handlers(&_reflection_entry); + reflection_union_type_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_type_ptr); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionMethod", reflection_method_functions); reflection_init_class_handlers(&_reflection_entry); reflection_method_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_abstract_ptr); |